<!DOCTYPE html PUBLIC '-//W3C//DTD HTML 4.01 Transitional//EN' 'http://www.w3.org/TR/html4/loose.dtd'>
<html lang="en" dir="ltr">
<head>
<title>The JSON-LD API 1.0</title>
<meta http-equiv="content-type" content="text/html; charset=UTF-8">
<!--
  === NOTA BENE ===
  For the three scripts below, if your spec resides on dev.w3 you can check them
  out in the same tree and use relative links so that they'll work offline,
  -->


<style>
.diff { font-weight:bold; color:#0a3; }
ol.algorithm.update { margin-left: 2em; }
ol.algorithm.update>li { list-style-type: none; }
ol.algorithm.update>li>span.list-number {
  display:block;
  float: left;
  margin-left: -3.5em;
}
</style>
<style type="text/css">
/*****************************************************************
 * ReSpec CSS
 * Robin Berjon (robin at berjon dot com)
 * v0.05 - 2009-07-31
 *****************************************************************/


/* --- INLINES --- */
em.rfc2119 { 
    text-transform:     lowercase;
    font-variant:       small-caps;
    font-style:         normal;
    color:              #900;
}

h1 acronym, h2 acronym, h3 acronym, h4 acronym, h5 acronym, h6 acronym, a acronym,
h1 abbr, h2 abbr, h3 abbr, h4 abbr, h5 abbr, h6 abbr, a abbr {
    border: none;
}

dfn {
    font-weight:    bold;
}

a.internalDFN {
    color:  inherit;
    border-bottom:  1px solid #99c;
    text-decoration:    none;
}

a.externalDFN {
    color:  inherit;
    border-bottom:  1px dotted #ccc;
    text-decoration:    none;
}

a.bibref {
    text-decoration:    none;
}

code {
    color:  #ff4500;
}


/* --- WEB IDL --- */
pre.idl {
    border-top: 1px solid #90b8de;
    border-bottom: 1px solid #90b8de;
    padding:    1em;
    line-height:    120%;
}

pre.idl::before {
    content:    "WebIDL";
    display:    block;
    width:      150px;
    background: #90b8de;
    color:  #fff;
    font-family:    initial;
    padding:    3px;
    font-weight:    bold;
    margin: -1em 0 1em -1em;
}

.idlType {
    color:  #ff4500;
    font-weight:    bold;
    text-decoration:    none;
}

/*.idlModule*/
/*.idlModuleID*/
/*.idlInterface*/
.idlInterfaceID, .idlDictionaryID {
    font-weight:    bold;
    color:  #005a9c;
}

.idlSuperclass {
    font-style: italic;
    color:  #005a9c;
}

/*.idlAttribute*/
.idlAttrType, .idlFieldType, .idlMemberType {
    color:  #005a9c;
}
.idlAttrName, .idlFieldName, .idlMemberName {
    color:  #ff4500;
}
.idlAttrName a, .idlFieldName a, .idlMemberName a {
    color:  #ff4500;
    border-bottom:  1px dotted #ff4500;
    text-decoration: none;
}

/*.idlMethod*/
.idlMethType {
    color:  #005a9c;
}
.idlMethName {
    color:  #ff4500;
}
.idlMethName a {
    color:  #ff4500;
    border-bottom:  1px dotted #ff4500;
    text-decoration: none;
}

/*.idlParam*/
.idlParamType {
    color:  #005a9c;
}
.idlParamName {
    font-style: italic;
}

.extAttr {
    color:  #666;
}

/*.idlConst*/
.idlConstType {
    color:  #005a9c;
}
.idlConstName {
    color:  #ff4500;
}
.idlConstName a {
    color:  #ff4500;
    border-bottom:  1px dotted #ff4500;
    text-decoration: none;
}

/*.idlException*/
.idlExceptionID {
    font-weight:    bold;
    color:  #c00;
}

.idlTypedefID, .idlTypedefType {
    color:  #005a9c;
}

.idlRaises, .idlRaises a.idlType, .idlRaises a.idlType code, .excName a, .excName a code {
    color:  #c00;
    font-weight:    normal;
}

.excName a {
    font-family:    monospace;
}

.idlRaises a.idlType, .excName a.idlType {
    border-bottom:  1px dotted #c00;
}

.excGetSetTrue, .excGetSetFalse, .prmNullTrue, .prmNullFalse, .prmOptTrue, .prmOptFalse {
    width:  45px;
    text-align: center;
}
.excGetSetTrue, .prmNullTrue, .prmOptTrue { color:  #0c0; }
.excGetSetFalse, .prmNullFalse, .prmOptFalse { color:  #c00; }

.idlImplements a {
    font-weight:    bold;
}

dl.attributes, dl.methods, dl.constants, dl.fields, dl.dictionary-members {
    margin-left:    2em;
}

.attributes dt, .methods dt, .constants dt, .fields dt, .dictionary-members dt {
    font-weight:    normal;
}

.attributes dt code, .methods dt code, .constants dt code, .fields dt code, .dictionary-members dt code {
    font-weight:    bold;
    color:  #000;
    font-family:    monospace;
}

.attributes dt code, .fields dt code, .dictionary-members dt code {
    background:  #ffffd2;
}

.attributes dt .idlAttrType code, .fields dt .idlFieldType code, .dictionary-members dt .idlMemberType code {
    color:  #005a9c;
    background:  transparent;
    font-family:    inherit;
    font-weight:    normal;
    font-style: italic;
}

.methods dt code {
    background:  #d9e6f8;
}

.constants dt code {
    background:  #ddffd2;
}

.attributes dd, .methods dd, .constants dd, .fields dd, .dictionary-members dd {
    margin-bottom:  1em;
}

table.parameters, table.exceptions {
    border-spacing: 0;
    border-collapse:    collapse;
    margin: 0.5em 0;
    width:  100%;
}
table.parameters { border-bottom:  1px solid #90b8de; }
table.exceptions { border-bottom:  1px solid #deb890; }

.parameters th, .exceptions th {
    color:  #fff;
    padding:    3px 5px;
    text-align: left;
    font-family:    initial;
    font-weight:    normal;
    text-shadow:    #666 1px 1px 0;
}
.parameters th { background: #90b8de; }
.exceptions th { background: #deb890; }

.parameters td, .exceptions td {
    padding:    3px 10px;
    border-top: 1px solid #ddd;
    vertical-align: top;
}

.parameters tr:first-child td, .exceptions tr:first-child td {
    border-top: none;
}

.parameters td.prmName, .exceptions td.excName, .exceptions td.excCodeName {
    width:  100px;
}

.parameters td.prmType {
    width:  120px;
}

table.exceptions table {
    border-spacing: 0;
    border-collapse:    collapse;
    width:  100%;
}

/* --- TOC --- */
.toc a {
    text-decoration:    none;
}

a .secno {
    color:  #000;
}

/* --- TABLE --- */
table.simple {
    border-spacing: 0;
    border-collapse:    collapse;
    border-bottom:  3px solid #005a9c;
}

.simple th {
    background: #005a9c;
    color:  #fff;
    padding:    3px 5px;
    text-align: left;
}

.simple th[scope="row"] {
    background: inherit;
    color:  inherit;
    border-top: 1px solid #ddd;
}

.simple td {
    padding:    3px 10px;
    border-top: 1px solid #ddd;
}

.simple tr:nth-child(even) {
    background: #f0f6ff;
}

/* --- DL --- */
.section dd > p:first-child {
    margin-top: 0;
}

.section dd > p:last-child {
    margin-bottom: 0;
}

.section dd {
    margin-bottom:  1em;
}

.section dl.attrs dd, .section dl.eldef dd {
    margin-bottom:  0;
}

/* --- EXAMPLES --- */
pre.example {
    border-top: 1px solid #ff4500;
    border-bottom: 1px solid #ff4500;
    padding:    1em;
    margin-top: 1em;
}

pre.example::before {
    content:    "Example";
    display:    block;
    width:      150px;
    background: #ff4500;
    color:  #fff;
    font-family:    initial;
    padding:    3px;
    font-weight:    bold;
    margin: -1em 0 1em -1em;
}

/* --- EDITORIAL NOTES --- */
.issue {
    padding:    1em;
    margin: 1em 0em 0em;
    border: 1px solid #f00;
    background: #ffc;
}

.issue::before {
    content:    "Issue";
    display:    block;
    width:  150px;
    margin: -1.5em 0 0.5em 0;
    font-weight:    bold;
    border: 1px solid #f00;
    background: #fff;
    padding:    3px 1em;
}

.note {
    margin: 1em 0em 0em;
    padding:    1em;
    border: 2px solid #cff6d9;
    background: #e2fff0;
}

.note::before {
    content:    "Note";
    display:    block;
    width:  150px;
    margin: -1.5em 0 0.5em 0;
    font-weight:    bold;
    border: 1px solid #cff6d9;
    background: #fff;
    padding:    3px 1em;
}

/* --- Best Practices --- */
div.practice {
    border: solid #bebebe 1px;
    margin: 2em 1em 1em 2em;
}

span.practicelab {
    margin: 1.5em 0.5em 1em 1em;
    font-weight: bold;
    font-style: italic;
}

span.practicelab   { background: #dfffff; }

span.practicelab {
    position: relative;
    padding: 0 0.5em;
    top: -1.5em;
}

p.practicedesc {
    margin: 1.5em 0.5em 1em 1em;
}

@media screen {
    p.practicedesc {
        position: relative;
        top: -2em;
        padding: 0;
        margin: 1.5em 0.5em -1em 1em;
    }
}

/* --- SYNTAX HIGHLIGHTING --- */
pre.sh_sourceCode {
  background-color: white;
  color: black;
  font-style: normal;
  font-weight: normal;
}

pre.sh_sourceCode .sh_keyword { color: #005a9c; font-weight: bold; }           /* language keywords */
pre.sh_sourceCode .sh_type { color: #666; }                            /* basic types */
pre.sh_sourceCode .sh_usertype { color: teal; }                             /* user defined types */
pre.sh_sourceCode .sh_string { color: red; font-family: monospace; }        /* strings and chars */
pre.sh_sourceCode .sh_regexp { color: orange; font-family: monospace; }     /* regular expressions */
pre.sh_sourceCode .sh_specialchar { color: 	#ffc0cb; font-family: monospace; }  /* e.g., \n, \t, \\ */
pre.sh_sourceCode .sh_comment { color: #A52A2A; font-style: italic; }         /* comments */
pre.sh_sourceCode .sh_number { color: purple; }                             /* literal numbers */
pre.sh_sourceCode .sh_preproc { color: #00008B; font-weight: bold; }       /* e.g., #include, import */
pre.sh_sourceCode .sh_symbol { color: blue; }                            /* e.g., *, + */
pre.sh_sourceCode .sh_function { color: black; font-weight: bold; }         /* function calls and declarations */
pre.sh_sourceCode .sh_cbracket { color: red; }                              /* block brackets (e.g., {, }) */
pre.sh_sourceCode .sh_todo { font-weight: bold; background-color: #00FFFF; }   /* TODO and FIXME */

/* Predefined variables and functions (for instance glsl) */
pre.sh_sourceCode .sh_predef_var { color: #00008B; }
pre.sh_sourceCode .sh_predef_func { color: #00008B; font-weight: bold; }

/* for OOP */
pre.sh_sourceCode .sh_classname { color: teal; }

/* line numbers (not yet implemented) */
pre.sh_sourceCode .sh_linenum { display: none; }

/* Internet related */
pre.sh_sourceCode .sh_url { color: blue; text-decoration: underline; font-family: monospace; }

/* for ChangeLog and Log files */
pre.sh_sourceCode .sh_date { color: blue; font-weight: bold; }
pre.sh_sourceCode .sh_time, pre.sh_sourceCode .sh_file { color: #00008B; font-weight: bold; }
pre.sh_sourceCode .sh_ip, pre.sh_sourceCode .sh_name { color: #006400; }

/* for Prolog, Perl... */
pre.sh_sourceCode .sh_variable { color: #006400; }

/* for LaTeX */
pre.sh_sourceCode .sh_italics { color: #006400; font-style: italic; }
pre.sh_sourceCode .sh_bold { color: #006400; font-weight: bold; }
pre.sh_sourceCode .sh_underline { color: #006400; text-decoration: underline; }
pre.sh_sourceCode .sh_fixed { color: green; font-family: monospace; }
pre.sh_sourceCode .sh_argument { color: #006400; }
pre.sh_sourceCode .sh_optionalargument { color: purple; }
pre.sh_sourceCode .sh_math { color: orange; }
pre.sh_sourceCode .sh_bibtex { color: blue; }

/* for diffs */
pre.sh_sourceCode .sh_oldfile { color: orange; }
pre.sh_sourceCode .sh_newfile { color: #006400; }
pre.sh_sourceCode .sh_difflines { color: blue; }

/* for css */
pre.sh_sourceCode .sh_selector { color: purple; }
pre.sh_sourceCode .sh_property { color: blue; }
pre.sh_sourceCode .sh_value { color: #006400; font-style: italic; }

/* other */
pre.sh_sourceCode .sh_section { color: black; font-weight: bold; }
pre.sh_sourceCode .sh_paren { color: red; }
pre.sh_sourceCode .sh_attribute { color: #006400; }

</style><style type="text/css">ol.algorithm { counter-reset:numsection; list-style-type: none; }
ol.algorithm li { margin: 0.5em 0; }
ol.algorithm li:before { font-weight: bold; counter-increment: numsection; content: counters(numsection, ".") ") "; }

</style><link href="http://www.w3.org/StyleSheets/TR/w3c-unofficial" rel="stylesheet" type="text/css" charset="utf-8"><style type='text/css'>
.diff-old-a {
  font-size: smaller;
  color: red;
}

.diff-new { background-color: yellow; }
.diff-chg { background-color: lime; }
.diff-new:before,
.diff-new:after
    { content: "\2191" }
.diff-chg:before, .diff-chg:after
    { content: "\2195" }
.diff-old { text-decoration: line-through; background-color: #FBB; }
.diff-old:before,
.diff-old:after
    { content: "\2193" }
:focus { border: thin red solid}
</style>
</head>


<body style="display: inherit; ">
<div class="head">
<p>
</p>
<h1 class="title" id="title">
The
JSON-LD
API
1.0
</h1>
<h2 id="subtitle">
An
Application
Programming
Interface
for
the
JSON-LD
Syntax
</h2>
<h2 id="unofficial-draft-12-january-2012">
Unofficial
Draft
<del class="diff-old">24
October
2011
</del>
<ins class="diff-chg">12
January
2012
</ins>
</h2>
<dl>
<dt>
Editors:
</dt>
<dd>
<a href="http://manu.sporny.org/">
Manu
Sporny
</a>,
<a href="http://digitalbazaar.com/">
Digital
Bazaar
</a>
</dd>
<dd>
<a href="http://greggkellogg.net/">
Gregg
Kellogg
</a>,
<a href="http://kellogg-assoc.com/">
Kellogg
Associates
</a>
</dd>
<dd>
<a href="http://digitalbazaar.com/">
Dave
Longley
</a>,
<a href="http://digitalbazaar.com/">
Digital
Bazaar
</a>
</dd>
<dt>
Authors:
</dt>
<dd>
<a href="http://digitalbazaar.com/">
Dave
Longley
</a>,
<a href="http://digitalbazaar.com/">
Digital
Bazaar
</a>
</dd>
<dd>
<a href="http://digitalbazaar.com/">
Manu
Sporny
</a>,
<a href="http://digitalbazaar.com/">
Digital
Bazaar
</a>
</dd>
<dd>
<a href="http://greggkellogg.net/">
Gregg
Kellogg
</a>,
<a href="http://kellogg-assoc.com/">
Kellogg
Associates
</a>
</dd>
</dl>
<p>
This
document
is
also
available
in
this
non-normative
format:
<a href="diff-20111023.html">
diff
to
previous
version
</a>.
</p>
<p class="copyright">
This
document
is
licensed
under
a
<a class="subfoot" href="http://creativecommons.org/licenses/by/3.0/" rel="license">
Creative
Commons
Attribution
3.0
License
</a>.
</p>
<hr>
</div>
<div id="abstract" class="introductory section">
<h2>
Abstract
</h2>
<p>
JSON
[
<cite>
<a class="bibref" rel="biblioentry" href="#bib-RFC4627">
RFC4627
</a>
</cite>
]
has
proven
to
be
a
highly
useful
object
serialization
and
messaging
format.
JSON-LD
[
<cite>
<a class="bibref" rel="biblioentry" href="#bib-JSON-LD">
JSON-LD
</a>
</cite>
]
harmonizes
the
representation
of
Linked
Data
in
JSON
by
outlining
a
common
JSON
representation
format
for
expressing
directed
graphs;
mixing
both
Linked
Data
and
non-Linked
Data
in
a
single
document.
This
document
outlines
an
Application
Programming
Interface
and
a
set
of
algorithms
for
programmatically
transforming
JSON-LD
documents.
</p>
</div>
<div id="sotd" class="introductory section">
<h2>
Status
of
This
Document
</h2>
<p>
This
document
is
merely
a
public
working
draft
of
a
potential
specification.
It
has
no
official
standing
of
any
kind
and
does
not
represent
the
support
or
consensus
of
any
standards
organisation.
</p>
<p>
This
document
is
an
experimental
work
in
progress.
</p>
</div>
<div id="toc" class="section">
<h2 class="introductory">
Table
of
Contents
</h2>
<ul class="toc">
<li class="tocline">
<a href="#introduction" class="tocxref">
<span class="secno">
1.
</span>
Introduction
</a>
<ul class="toc">
<li class="tocline">
<a href="#how-to-read-this-document" class="tocxref">
<span class="secno">
1.1
</span>
How
to
Read
this
Document
</a>
</li>
<li class="tocline">
<a href="#linked-data" class="tocxref">
<span class="secno">
1.2
</span>
Linked
Data
</a>
</li>
<li class="tocline">
<a href="#contributing" class="tocxref">
<span class="secno">
1.3
</span>
Contributing
</a>
</li>
</ul>
</li>
<li class="tocline">
<a href="#the-application-programming-interface" class="tocxref">
<span class="secno">
2.
</span>
The
Application
Programming
Interface
</a>
<ul class="toc">
<li class="tocline">
<a href="#jsonldprocessor" class="tocxref">
<span class="secno">
2.1
</span>
JsonLdProcessor
</a>
<ul class="toc">
<li class="tocline">
<a href="#methods" class="tocxref">
<span class="secno">
2.1.1
</span>
Methods
</a>
</li>
</ul>
</li>
<li class="tocline">
<a href="#jsonldtriplecallback" class="tocxref">
<span class="secno">
2.2
</span>
JsonLdTripleCallback
</a>
<ul class="toc">
<li class="tocline">
<a href="#methods-1" class="tocxref">
<span class="secno">
2.2.1
</span>
Methods
</a>
</li>
</ul>
</li>
</ul>
</li>
<li class="tocline">
<a href="#algorithms" class="tocxref">
<span class="secno">
3.
</span>
Algorithms
</a>
<ul class="toc">
<li class="tocline">
<a href="#syntax-tokens-and-keywords" class="tocxref">
<span class="secno">
3.1
</span>
Syntax
Tokens
and
Keywords
</a>
</li>
<li class="tocline">
<a href="#algorithm-terms" class="tocxref">
<span class="secno">
3.2
</span>
Algorithm
Terms
</a>
</li>
<li class="tocline">
<a href="#context-1" class="tocxref">
<span class="secno">
3.3
</span>
Context
</a>
</li>
<li class="tocline">
<a href="#iri-expansion" class="tocxref">
<span class="secno">
3.4
</span>
<del class="diff-old">Value
Compaction
</del>
<del class="diff-old">3.5
Expansion
3.5.1
</del>
<abbr title="Internationalized Resource Identifier">
<ins class="diff-chg">IRI
</ins></abbr>
Expansion
<del class="diff-old">Algorithm
</del>
</a>
</li>
<li class="tocline">
<a href="#iri-compaction" class="tocxref">
<span class="secno">
<del class="diff-old">3.6
</del>
<ins class="diff-chg">3.5
</ins>
</span>
<del class="diff-old">Compaction
</del>
<del class="diff-old">3.6.1
</del>
<abbr title="Internationalized Resource Identifier">
<ins class="diff-chg">IRI
</ins></abbr>
Compaction
<del class="diff-old">Algorithm
</del>
</a>
</li>
<del class="diff-old">3.7
Framing
</del>
<li class="tocline">
<a href="#value-expansion" class="tocxref">
<span class="secno">
<del class="diff-old">3.7.1
</del>
<ins class="diff-chg">3.6
</ins>
</span>
<del class="diff-old">Framing
Algorithm
Terms
</del>
<ins class="diff-chg">Value
Expansion
</ins>
</a>
</li>
<li class="tocline">
<a href="#value-compaction" class="tocxref">
<span class="secno">
<del class="diff-old">3.7.2
</del>
<ins class="diff-chg">3.7
</ins>
</span>
<del class="diff-old">Framing
Algorithm
</del>
<ins class="diff-chg">Value
Compaction
</ins>
</a>
</li>
<li class="tocline">
<a href="#expansion" class="tocxref">
<span class="secno">
3.8
</span>
<del class="diff-old">Normalization
</del>
<ins class="diff-chg">Expansion
</ins>
</a>
<ul class="toc">
<li class="tocline">
<a href="#expansion-algorithm" class="tocxref">
<span class="secno">
3.8.1
</span>
<del class="diff-old">Normalization
Algorithm
Terms
3.8.2
Normalization
State
3.8.3
Normalization
Algorithm
3.8.4
Node
Relabeling
</del>
<ins class="diff-chg">Expansion
</ins>
Algorithm
</a>
</li>
<del class="diff-old">3.8.5
Deterministic
Labeling
Algorithm
</del>
</ul>
</li>
<li class="tocline">
<a href="#compaction" class="tocxref">
<span class="secno">
<del class="diff-old">3.8.6
</del>
<ins class="diff-chg">3.9
</ins>
</span>
<del class="diff-old">Shallow
Comparison
Algorithm
</del>
<ins class="diff-chg">Compaction
</ins>
</a>
<ul class="toc">
<li class="tocline">
<a href="#compaction-algorithm" class="tocxref">
<span class="secno">
<del class="diff-old">3.8.7
</del>
<ins class="diff-chg">3.9.1
</ins>
</span>
<del class="diff-old">Object
Comparison
</del>
<ins class="diff-chg">Compaction
</ins>
Algorithm
</a>
</li>
<del class="diff-old">3.8.8
Deep
Comparison
Algorithm
</del>
</ul>
</li>
<li class="tocline">
<a href="#framing" class="tocxref">
<span class="secno">
<del class="diff-old">3.8.9
</del>
<ins class="diff-chg">3.10
</ins>
</span>
<del class="diff-old">Node
Serialization
Algorithm
</del>
<ins class="diff-chg">Framing
</ins>
</a>
<ul class="toc">
<li class="tocline">
<a href="#framing-algorithm-terms" class="tocxref">
<span class="secno">
<del class="diff-old">3.8.10
</del>
<ins class="diff-chg">3.10.1
</ins>
</span>
<del class="diff-old">Serialization
Label
Generation
</del>
<ins class="diff-chg">Framing
</ins>
Algorithm
<ins class="diff-new">Terms
</ins>
</a>
</li>
<li class="tocline">
<a href="#framing-algorithm" class="tocxref">
<span class="secno">
<del class="diff-old">3.8.11
</del>
<ins class="diff-chg">3.10.2
</ins>
</span>
<del class="diff-old">Combinatorial
Serialization
</del>
<ins class="diff-chg">Framing
</ins>
Algorithm
</a>
</li>
<del class="diff-old">3.8.12
Serialization
Comparison
Algorithm
</del>
</ul>
</li>
<li class="tocline">
<a href="#normalization" class="tocxref">
<span class="secno">
<del class="diff-old">3.8.13
</del>
<ins class="diff-chg">3.11
</ins>
</span>
<del class="diff-old">Mapping
Serialization
Algorithm
</del>
<ins class="diff-chg">Normalization
</ins>
</a>
<ul class="toc">
<li class="tocline">
<a href="#normalization-algorithm" class="tocxref">
<span class="secno">
<del class="diff-old">3.8.14
</del>
<ins class="diff-chg">3.11.1
</ins>
</span>
<del class="diff-old">Label
Serialization
</del>
<ins class="diff-chg">Normalization
</ins>
Algorithm
</a>
</li>
</ul>
</li>
<li class="tocline">
<a href="#data-round-tripping" class="tocxref">
<span class="secno">
<del class="diff-old">3.9
</del>
<ins class="diff-chg">3.12
</ins>
</span>
Data
Round
Tripping
</a>
</li>
<li class="tocline">
<a href="#rdf-conversion" class="tocxref">
<span class="secno">
<del class="diff-old">3.10
</del>
<ins class="diff-chg">3.13
</ins>
</span>
RDF
Conversion
</a>
<ul class="toc">
<li class="tocline">
<a href="#overview" class="tocxref">
<span class="secno">
<del class="diff-old">3.10.1
</del>
<ins class="diff-chg">3.13.1
</ins>
</span>
Overview
</a>
</li>
<li class="tocline">
<a href="#rdf-conversion-algorithm-terms" class="tocxref">
<span class="secno">
<del class="diff-old">3.10.2
</del>
<ins class="diff-chg">3.13.2
</ins>
</span>
RDF
Conversion
Algorithm
Terms
</a>
</li>
<li class="tocline">
<a href="#rdf-conversion-algorithm" class="tocxref">
<span class="secno">
<del class="diff-old">3.10.3
</del>
<ins class="diff-chg">3.13.3
</ins>
</span>
RDF
Conversion
Algorithm
</a>
</li>
<li class="tocline">
<a href="#list-conversion" class="tocxref">
<span class="secno">
<del class="diff-old">3.10.4
</del>
<ins class="diff-chg">3.13.4
</ins>
</span>
<del class="diff-old">Acknowledgements
</del>
<ins class="diff-chg">List
Conversion
</ins>
</a>
</li>
</ul>
</li>
</ul>
</li>
<li class="tocline">
<a href="#acknowledgements" class="tocxref">
<span class="secno">
A.
</span>
<ins class="diff-new">Acknowledgements
</ins></a></li><li class="tocline"><a href="#appendix-b" class="tocxref"><span class="secno"><ins class="diff-new">
B.
</ins></span><ins class="diff-new">
Initial
Context
</ins></a></li><li class="tocline"><a href="#references" class="tocxref"><span class="secno"><ins class="diff-new">
C.
</ins></span>
References
</a>
<ul class="toc">
<li class="tocline">
<a href="#normative-references" class="tocxref">
<span class="secno">
<del class="diff-old">A.1
</del>
<ins class="diff-chg">C.1
</ins>
</span>
Normative
references
</a>
</li>
<li class="tocline">
<a href="#informative-references" class="tocxref">
<span class="secno">
<del class="diff-old">A.2
</del>
<ins class="diff-chg">C.2
</ins>
</span>
Informative
references
</a>
</li>
</ul>
</li>
</ul>
</div>
<div id="introduction" class="section">
<h2>
<span class="secno">
1.
</span>
Introduction
</h2>
<p>
JSON,
as
specified
in
[
<cite>
<a class="bibref" rel="biblioentry" href="#bib-RFC4627">
RFC4627
</a>
</cite>
],
is
a
simple
language
for
representing
data
on
the
Web.
Linked
Data
is
a
technique
for
creating
a
graph
of
interlinked
data
across
different
documents
or
Web
sites.
Data
entities
are
described
using
<a class="tref internalDFN" title="iri" href="#dfn-iri">
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
</a>
s,
which
are
typically
dereferencable
and
thus
may
be
used
to
find
more
information
about
an
entity,
creating
a
<del class="diff-old">&quot;Web
</del>
<ins class="diff-chg">"Web
</ins>
of
<del class="diff-old">Knowledge&quot;.
</del>
<ins class="diff-chg">Knowledge".
</ins>
JSON-LD
is
intended
to
be
a
simple
publishing
method
for
expressing
not
only
Linked
Data
in
JSON,
but
also
for
adding
semantics
to
existing
JSON.
</p>
<p>
JSON-LD
is
designed
as
a
light-weight
syntax
that
can
be
used
to
express
Linked
Data.
It
is
primarily
intended
to
be
a
way
to
use
Linked
Data
in
Javascript
and
other
Web-based
programming
environments.
It
is
also
useful
when
building
interoperable
Web
services
and
when
storing
Linked
Data
in
JSON-based
document
storage
engines.
It
is
practical
and
designed
to
be
as
simple
as
possible,
utilizing
the
large
number
of
JSON
parsers
and
libraries
available
today.
It
is
designed
to
be
able
to
express
key-value
pairs,
RDF
data,
RDFa
[
<cite>
<a class="bibref" rel="biblioentry" href="#bib-RDFA-CORE">
RDFA-CORE
</a>
</cite>
]
data,
Microformats
[
<cite>
<a class="bibref" rel="biblioentry" href="#bib-MICROFORMATS">
MICROFORMATS
</a>
</cite>
]
data,
and
Microdata
[
<cite>
<a class="bibref" rel="biblioentry" href="#bib-MICRODATA">
MICRODATA
</a>
</cite>
].
That
is,
it
supports
every
major
Web-based
structured
data
model
in
use
today.
</p>
<p>
The
syntax
does
not
necessarily
require
applications
to
change
their
JSON,
but
allows
to
easily
add
meaning
by
adding
context
in
a
way
that
is
either
in-band
or
out-of-band.
The
syntax
is
designed
to
not
disturb
already
deployed
systems
running
on
JSON,
but
provide
a
smooth
upgrade
path
from
JSON
to
JSON
with
added
semantics.
Finally,
the
format
is
intended
to
be
easy
to
parse,
efficient
to
generate,
convertible
to
RDF
in
one
pass,
and
require
a
very
small
memory
footprint
in
order
to
operate.
</p>
<div id="how-to-read-this-document" class="section">
<h3>
<span class="secno">
1.1
</span>
How
to
Read
this
Document
</h3>
<p>
This
document
is
a
detailed
specification
for
a
serialization
of
Linked
Data
in
JSON.
The
document
is
primarily
intended
for
the
following
audiences:
</p>
<ul>
<li>
Authors
that
want
a
very
detailed
view
of
how
JSON-LD
processors
operate.
</li>
<li>
Software
developers
that
want
to
implement
processors
and
APIs
for
JSON-LD.
</li>
</ul>
<p>
To
understand
the
basics
in
this
specification
you
must
first
be
familiar
with
JSON,
which
is
detailed
in
[
<cite>
<a class="bibref" rel="biblioentry" href="#bib-RFC4627">
RFC4627
</a>
</cite>
].
You
must
also
understand
the
JSON-LD
Syntax
[
<cite>
<a class="bibref" rel="biblioentry" href="#bib-JSON-LD">
JSON-LD
</a>
</cite>
],
which
is
the
base
syntax
used
by
all
of
the
algorithms
in
this
document.
To
understand
the
API
and
how
it
is
intended
to
operate
in
a
programming
environment,
it
is
useful
to
have
working
knowledge
of
the
JavaScript
programming
language
[
<cite>
<a class="bibref" rel="biblioentry" href="#bib-ECMA-262">
ECMA-262
</a>
</cite>
]
and
WebIDL
[
<cite>
<a class="bibref" rel="biblioentry" href="#bib-WEBIDL">
WEBIDL
</a>
</cite>
].
To
understand
how
JSON-LD
maps
to
RDF,
it
is
helpful
to
be
familiar
with
the
basic
RDF
concepts
[
<cite>
<a class="bibref" rel="biblioentry" href="#bib-RDF-CONCEPTS">
RDF-CONCEPTS
</a>
</cite>
].
</p>
<p>
Examples
may
contain
references
to
existing
vocabularies
and
use
<a class="tref internalDFN" title="prefix" href="#dfn-prefix">
prefix
</a>
es
to
refer
to
Web
Vocabularies.
The
following
is
a
list
of
all
vocabularies
and
their
<a class="tref internalDFN" title="prefix" href="#dfn-prefix">
prefix
</a>
abbreviations,
as
used
in
this
document:
</p>
<ul>
<li>
The
<a href="http://purl.org/dc/terms/">
Dublin
Core
</a>
vocabulary
(abbreviation:
<code>
dc
</code>,
e.g.,
<code>
dc:title
</code>
)
</li>
<li>
The
<a href="http://xmlns.com/foaf/0.1/">
Friend
of
a
Friend
</a>
vocabulary
(abbreviation:
<code>
foaf
</code>,
e.g.,
<code>
foaf:knows
</code>
)
</li>
<li>
The
<a href="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
RDF
</a>
vocabulary
(abbreviation:
<code>
rdf
</code>,
e.g.,
<code>
rdf:type
</code>
)
</li>
<li>
The
<a href="http://www.w3.org/2001/XMLSchema#">
XSD
</a>
vocabulary
(abbreviation:
<code>
xsd
</code>,
e.g.,
<code>
xsd:integer
</code>
)
</li>
</ul>
<p>
JSON
[
<cite>
<a class="bibref" rel="biblioentry" href="#bib-RFC4627">
RFC4627
</a>
</cite>
]
defines
several
terms
which
are
used
throughout
this
document:
</p>
<dl>
<dt>
<dfn title="json_object" id="dfn-json_object">
JSON
Object
</dfn>
</dt>
<dd>
An
object
structure
is
represented
as
a
pair
of
curly
brackets
surrounding
zero
or
more
name/value
pairs
(or
members).
A
name
is
a
<a class="tref internalDFN" title="string" href="#dfn-string">
string
</a>.
A
single
colon
comes
after
each
name,
separating
the
name
from
the
value.
A
single
comma
separates
a
value
from
a
following
name.
The
names
within
an
object
<em class="rfc2119" title="should">
should
</em>
be
unique.
</dd>
<dt>
<dfn title="array" id="dfn-array">
array
</dfn>
</dt>
<dd>
An
array
is
an
ordered
collection
of
values.
An
array
structure
is
represented
as
square
brackets
surrounding
zero
or
more
values
(or
elements).
Elements
are
separated
by
commas.
Within
JSON-LD,
array
order
is
not
preserved
by
default,
unless
specific
markup
is
provided
(see
<a href="#lists">
Lists
</a>
).
This
is
because
the
basic
data
model
of
JSON-LD
is
a
<a class="tref internalDFN" title="linked_data_graph" href="#dfn-linked_data_graph">
linked
data
graph
</a>,
which
is
inherently
unordered.
</dd>
<dt>
<dfn title="string" id="dfn-string">
string
</dfn>
</dt>
<dd>
A
string
is
a
sequence
of
zero
or
more
Unicode
characters,
wrapped
in
double
quotes,
using
backslash
escapes.
A
character
is
represented
as
a
single
character
string.
</dd>
<dt>
<dfn title="number" id="dfn-number">
number
</dfn>
</dt>
<dd>
A
number
is
is
similar
to
that
used
in
most
programming
languages,
except
that
the
octal
and
hexadecimal
formats
are
not
used
and
that
leading
zeros
are
not
allowed.
</dd>
<dt>
<dfn title="true" id="dfn-true">
true
</dfn>
and
<dfn title="false" id="dfn-false">
false
</dfn>
</dt>
<dd>
Boolean
values.
</dd>
<dt>
<dfn title="null" id="dfn-null">
null
</dfn>
</dt>
<dd>
The
use
of
the
<em>
null
</em>
value
is
undefined
within
JSON-LD.
<div class="issue">
Supporting
<em>
null
</em>
in
JSON-LD
might
have
a
number
of
advantages
and
should
be
evaluated.
This
is
currently
an
<a href="https://github.com/json-ld/json-ld.org/issues/11">
open
issue
</a>.
</div>
</dd>
</dl>
<p>
</p>
</div>
<div id="linked-data" class="section">
<h3>
<span class="secno">
1.2
</span>
Linked
Data
</h3>
<p>
The
following
definition
for
<a class="tref internalDFN" title="linked_data" href="#dfn-linked_data">
Linked
Data
</a>
is
the
one
that
will
be
used
for
this
specification.
</p>
<ol>
<li>
<dfn title="linked_data" id="dfn-linked_data">
Linked
Data
</dfn>
is
a
set
of
documents,
each
containing
a
representation
of
a
linked
data
graph.
</li>
<li>
A
<dfn title="linked_data_graph" id="dfn-linked_data_graph">
linked
data
graph
</dfn>
is
an
unordered
labeled
directed
graph,
where
nodes
are
<a class="tref internalDFN" title="subject" href="#dfn-subject">
subject
</a>
s
or
<a class="tref internalDFN" title="object" href="#dfn-object">
object
</a>
s,
and
edges
are
properties.
</li>
<li>
A
<dfn title="subject" id="dfn-subject">
subject
</dfn>
is
any
node
in
a
<a class="tref internalDFN" title="linked_data_graph" href="#dfn-linked_data_graph">
linked
data
graph
</a>
with
at
least
one
outgoing
edge.
</li>
<li>
A
<a class="tref internalDFN" title="subject" href="#dfn-subject">
subject
</a>
<em class="rfc2119" title="should">
should
</em>
be
labeled
with
an
<a class="tref internalDFN" title="iri" href="#dfn-iri">
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
</a>
(an
Internationalized
Resource
Identifier
as
described
in
[
<cite>
<a class="bibref" rel="biblioentry" href="#bib-RFC3987">
RFC3987
</a>
</cite>
]).
</li>
<li>
An
<dfn title="object" id="dfn-object">
object
</dfn>
is
a
node
in
a
<a class="tref internalDFN" title="linked_data_graph" href="#dfn-linked_data_graph">
linked
data
graph
</a>
with
at
least
one
incoming
edge.
</li>
<li>
An
<a class="tref internalDFN" title="object" href="#dfn-object">
object
</a>
<em class="rfc2119" title="may">
may
</em>
be
labeled
with
an
<a class="tref internalDFN" title="iri" href="#dfn-iri">
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
</a>.
</li>
<li>
An
object
<em class="rfc2119" title="may">
may
</em>
be
a
<a class="tref internalDFN" title="subject" href="#dfn-subject">
subject
</a>
and
<a class="tref internalDFN" title="object" href="#dfn-object">
object
</a>
at
the
same
time.
</li>
<li>
A
<dfn title="property" id="dfn-property">
property
</dfn>
is
an
edge
of
the
<a class="tref internalDFN" title="linked_data_graph" href="#dfn-linked_data_graph">
linked
data
graph
</a>.
</li>
<li>
A
<a class="tref internalDFN" title="property" href="#dfn-property">
property
</a>
<em class="rfc2119" title="should">
should
</em>
be
labeled
with
an
<a class="tref internalDFN" title="iri" href="#dfn-iri">
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
</a>.
</li>
<li>
An
<a class="tref internalDFN" title="iri" href="#dfn-iri">
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
</a>
that
is
a
label
in
a
<a class="tref internalDFN" title="linked_data_graph" href="#dfn-linked_data_graph">
linked
data
graph
</a>
<em class="rfc2119" title="should">
should
</em>
be
dereferencable
to
a
<a class="tref internalDFN" title="linked_data" href="#dfn-linked_data">
Linked
Data
</a>
document
describing
the
labeled
<a class="tref internalDFN" title="subject" href="#dfn-subject">
subject
</a>,
<a class="tref internalDFN" title="object" href="#dfn-object">
object
</a>
or
<a class="tref internalDFN" title="property" href="#dfn-property">
property
</a>.
</li>
<li>
A
<dfn title="literal" id="dfn-literal">
literal
</dfn>
is
an
<a class="tref internalDFN" title="object" href="#dfn-object">
object
</a>
with
a
label
that
is
not
an
<a class="tref internalDFN" title="iri" href="#dfn-iri">
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
</a>
</li>
</ol>
<p>
Note
that
the
definition
for
<a class="tref internalDFN" title="linked_data" href="#dfn-linked_data">
Linked
Data
</a>
above
is
silent
on
the
topic
of
unlabeled
nodes.
Unlabeled
nodes
are
not
considered
<a class="tref internalDFN" title="linked_data" href="#dfn-linked_data">
Linked
Data
</a>.
However,
this
specification
allows
for
the
expression
of
unlabled
nodes,
as
most
graph-based
data
sets
on
the
Web
contain
a
number
of
associated
nodes
that
are
not
named
and
thus
are
not
directly
de-referenceable.
</p>
</div>
<div id="contributing" class="section">
<h3>
<span class="secno">
1.3
</span>
Contributing
</h3>
<p>
There
are
a
number
of
ways
that
one
may
participate
in
the
development
of
this
specification:
</p>
<ul>
<li>
Technical
discussion
typically
occurs
on
the
public
mailing
list:
<a href="http://lists.w3.org/Archives/Public/public-linked-json/">
public-linked-json@w3.org
</a>
</li>
<li>
<a href="http://json-ld.org/minutes/">
Public
teleconferences
</a>
are
held
on
Tuesdays
at
1500UTC
on
the
second
and
fourth
week
of
each
month.
</li>
<li>
Specification
bugs
and
issues
should
be
reported
in
the
<a href="https://github.com/json-ld/json-ld.org/issues">
issue
tracker
</a>.
</li>
<li>
<a href="https://github.com/json-ld/json-ld.org/tree/main/spec">
Source
code
</a>
for
the
specification
can
be
found
on
Github.
</li>
<li>
The
<a href="http://webchat.freenode.net/?channels=#json-ld">
#json-ld
</a>
IRC
channel
is
available
for
real-time
discussion
on
irc.freenode.net.
</li>
</ul>
</div>
</div>
<div id="the-application-programming-interface" class="section">
<h2>
<span class="secno">
2.
</span>
The
Application
Programming
Interface
</h2>
<p>
This
API
provides
a
clean
mechanism
that
enables
developers
to
convert
JSON-LD
data
into
a
a
variety
of
output
formats
that
are
easier
to
work
with
in
various
programming
languages.
If
a
JSON-LD
API
is
provided
in
a
programming
environment,
the
entirety
of
the
following
API
<em class="rfc2119" title="must">
must
</em>
be
implemented.
</p>
<div id="jsonldprocessor" class="section">
<h3>
<span class="secno">
2.1
</span>
JsonLdProcessor
</h3>
<del class="diff-old">]
interface  {
};
</del>
    <pre class="idl"><span class="idlInterface" id="idl-def-JsonLdProcessor">[<span class="extAttr">NoInterfaceObject</span>]
<ins class="diff-chg">interface <span class="idlInterfaceID">JsonLdProcessor</span> {
</ins><span class="idlMethod">    <span class="idlMethType"><a>object</a></span>    <span class="idlMethName"><a href="#widl-JsonLdProcessor-expand-object-object-input-object-context">expand</a></span> (<span class="idlParam"><span class="idlParamType"><a>object</a></span> <span class="idlParamName">input</span></span>, <span class="idlParam">optional <span class="idlParamType"><a>object</a>?</span> <span class="idlParamName">context</span></span>) raises (<span class="idlRaises"><a>InvalidContext</a></span>);</span>
<span class="idlMethod">    <span class="idlMethType"><a>object</a></span>    <span class="idlMethName"><a href="#widl-JsonLdProcessor-compact-object-object-input-object-context">compact</a></span> (<span class="idlParam"><span class="idlParamType"><a>object</a></span> <span class="idlParamName">input</span></span>, <span class="idlParam">optional <span class="idlParamType"><a>object</a>?</span> <span class="idlParamName">context</span></span>) raises (<span class="idlRaises"><a>InvalidContext</a></span>, <span class="idlRaises"><a>ProcessingError</a></span>);</span>
<span class="idlMethod">    <span class="idlMethType"><a>object</a></span>    <span class="idlMethName"><a href="#widl-JsonLdProcessor-frame-object-object-input-object-frame-object-options">frame</a></span> (<span class="idlParam"><span class="idlParamType"><a>object</a></span> <span class="idlParamName">input</span></span>, <span class="idlParam"><span class="idlParamType"><a>object</a></span> <span class="idlParamName">frame</span></span>, <span class="idlParam"><span class="idlParamType"><a>object</a></span> <span class="idlParamName">options</span></span>) raises (<span class="idlRaises"><a>InvalidFrame</a></span>);</span>
<span class="idlMethod">    <span class="idlMethType"><a>DOMString</a></span> <span class="idlMethName"><a href="#widl-JsonLdProcessor-normalize-DOMString-object-input-object-context">normalize</a></span> (<span class="idlParam"><span class="idlParamType"><a>object</a></span> <span class="idlParamName">input</span></span>, <span class="idlParam">optional <span class="idlParamType"><a>object</a>?</span> <span class="idlParamName">context</span></span>) raises (<span class="idlRaises"><a>InvalidContext</a></span>);</span>
<span class="idlMethod">    <span class="idlMethType"><a>void</a></span>      <span class="idlMethName"><a href="#widl-JsonLdProcessor-triples-void-object-input-JsonLdTripleCallback-tripleCallback-object-context">triples</a></span> (<span class="idlParam"><span class="idlParamType"><a>object</a></span> <span class="idlParamName">input</span></span>, <span class="idlParam"><span class="idlParamType"><a href="#idl-def-JsonLdTripleCallback" class="idlType"><code>JsonLdTripleCallback</code></a></span> <span class="idlParamName">tripleCallback</span></span>, <span class="idlParam">optional <span class="idlParamType"><a>object</a>?</span> <span class="idlParamName">context</span></span>) raises (<span class="idlRaises"><a>InvalidContext</a></span>);</span>
<ins class="diff-chg">
};</span>
</ins>
</pre>
<div id="methods" class="section">
<h4>
<span class="secno">
2.1.1
</span>
Methods
</h4>
<dl class="methods">
<dt id="widl-JsonLdProcessor-compact-object-object-input-object-context">
<code>
compact
</code>
</dt>
<dd>
<a href="#compaction">
Compacts
</a>
the
given
<code>
input
</code>
according
to
the
steps
in
the
<a href="#compaction-algorithm">
Compaction
Algorithm
</a>.
The
<code>
input
</code>
<em class="rfc2119" title="must">
must
</em>
be
copied,
compacted
and
returned
if
there
are
no
errors.
If
the
compaction
fails,
an
appropirate
exception
<em class="rfc2119" title="must">
must
</em>
be
thrown.
<table class="parameters">
<tr>
<th>
Parameter
</th>
<th>
Type
</th>
<th>
Nullable
</th>
<th>
Optional
</th>
<th>
Description
</th>
</tr>
<tr>
<td class="prmName">
input
</td>
<td class="prmType">
<code>
<a>
object
</a>
</code>
</td>
<td class="prmNullFalse">
<del class="diff-old">✘
</del>
<ins class="diff-chg">&#10008;
</ins>
</td>
<td class="prmOptFalse">
<del class="diff-old">✘
</del>
<ins class="diff-chg">&#10008;
</ins>
</td>
<td class="prmDesc">
The
JSON-LD
object
to
perform
compaction
on.
</td>
</tr>
<tr>
<td class="prmName">
context
</td>
<td class="prmType">
<code>
<a>
object
</a>
</code>
</td>
<td class="prmNullTrue">
<del class="diff-old">✔
</del>
<ins class="diff-chg">&#10004;
</ins>
</td>
<td class="prmOptTrue">
<del class="diff-old">✔
</del>
<ins class="diff-chg">&#10004;
</ins>
</td>
<td class="prmDesc">
The
base
context
to
use
when
compacting
the
<code>
input
</code>.
</td>
</tr>
</table>
<table class="exceptions">
<tr>
<th>
Exception
</th>
<th>
Description
</th>
</tr>
<tr>
<td class="excName">
<a>
InvalidContext
</a>
</td>
<td class="excDesc">
<table class="exceptionCodes">
<tr>
<td class="excCodeName">
<code>
INVALID_SYNTAX
</code>
</td>
<td class="excCodeDesc">
A
general
syntax
error
was
detected
in
the
<code>
@context
</code>.
For
example,
if
a
<code>
<del class="diff-old">@coerce
</del>
<ins class="diff-chg">@type
</ins>
</code>
key
maps
to
anything
other
than
<del class="diff-old">a
string
</del>
<code>
<ins class="diff-chg">@id
</ins></code>
or
an
<del class="diff-old">array
of
strings,
</del>
<ins class="diff-chg">absolute
</ins><abbr title="Internationalized Resource Identifier"><ins class="diff-chg">
IRI
</ins></abbr>,
this
exception
would
be
raised.
</td>
</tr>
<tr>
<td class="excCodeName">
<code>
<del class="diff-old">MULTIPLE_DATATYPES
</del>
<ins class="diff-chg">LOAD_ERROR
</ins>
</code>
</td>
<td class="excCodeDesc">
There
<del class="diff-old">is
more
than
one
target
datatype
specified
for
</del>
<ins class="diff-chg">was
</ins>
a
<del class="diff-old">single
property
in
the
list
of
coercion
rules.
This
means
that
the
processor
does
not
know
what
the
developer
intended
for
the
target
datatype
for
</del>
<ins class="diff-chg">problem
encountered
loading
</ins>
a
<del class="diff-old">property.
</del>
<ins class="diff-chg">remote
context.
</ins>
</td>
</tr>
</table>
</td>
</tr>
<tr>
<td class="excName">
<a>
ProcessingError
</a>
</td>
<td class="excDesc">
<table class="exceptionCodes">
<tr>
<td class="excCodeName">
<code>
LOSSY_COMPACTION
</code>
</td>
<td class="excCodeDesc">
The
compaction
would
lead
to
a
loss
of
information,
such
as
a
<code>
@language
</code>
value.
</td>
</tr>
<tr>
<td class="excCodeName">
<code>
CONFLICTING_DATATYPES
</code>
</td>
<td class="excCodeDesc">
The
target
datatype
specified
in
the
coercion
rule
and
the
datatype
for
the
typed
literal
do
not
match.
</td>
</tr>
</table>
</td>
</tr>
</table>
<div>
<em>
Return
type:
</em>
<code>
<a>
object
</a>
</code>
</div>
</dd>
<dt id="widl-JsonLdProcessor-expand-object-object-input-object-context">
<code>
expand
</code>
</dt>
<dd>
<a href="#expansion">
Expands
</a>
the
given
<code>
input
</code>
according
to
the
steps
in
the
<a href="#expansion-algorithm">
Expansion
Algorithm
</a>.
The
<code>
input
</code>
<em class="rfc2119" title="must">
must
</em>
be
copied,
expanded
and
returned
if
there
are
no
errors.
If
the
expansion
fails,
an
appropriate
exception
<em class="rfc2119" title="must">
must
</em>
be
thrown.
<table class="parameters">
<tr>
<th>
Parameter
</th>
<th>
Type
</th>
<th>
Nullable
</th>
<th>
Optional
</th>
<th>
Description
</th>
</tr>
<tr>
<td class="prmName">
input
</td>
<td class="prmType">
<code>
<a>
object
</a>
</code>
</td>
<td class="prmNullFalse">
<del class="diff-old">✘
</del>
<ins class="diff-chg">&#10008;
</ins>
</td>
<td class="prmOptFalse">
<del class="diff-old">✘
</del>
<ins class="diff-chg">&#10008;
</ins>
</td>
<td class="prmDesc">
The
JSON-LD
object
to
copy
and
perform
the
expansion
upon.
</td>
</tr>
<tr>
<td class="prmName">
context
</td>
<td class="prmType">
<code>
<a>
object
</a>
</code>
</td>
<td class="prmNullTrue">
<del class="diff-old">✔
</del>
<ins class="diff-chg">&#10004;
</ins>
</td>
<td class="prmOptTrue">
<del class="diff-old">✔
</del>
<ins class="diff-chg">&#10004;
</ins>
</td>
<td class="prmDesc">
An
external
context
to
use
additionally
to
the
context
embedded
in
<code>
input
</code>
when
expanding
the
<code>
input
</code>.
</td>
</tr>
</table>
<table class="exceptions">
<tr>
<th>
Exception
</th>
<th>
Description
</th>
</tr>
<tr>
<td class="excName">
<a>
InvalidContext
</a>
</td>
<td class="excDesc">
<table class="exceptionCodes">
<tr>
<td class="excCodeName">
<code>
INVALID_SYNTAX
</code>
</td>
<td class="excCodeDesc">
A
general
syntax
error
was
detected
in
the
<code>
@context
</code>.
For
example,
if
a
<code>
<del class="diff-old">@coerce
</del>
<ins class="diff-chg">@type
</ins>
</code>
key
maps
to
anything
other
than
<del class="diff-old">a
string
</del>
<code>
<ins class="diff-chg">@id
</ins></code>
or
an
<del class="diff-old">array
of
strings,
</del>
<ins class="diff-chg">absolute
</ins><abbr title="Internationalized Resource Identifier"><ins class="diff-chg">
IRI
</ins></abbr>,
this
exception
would
be
raised.
</td>
</tr>
<tr>
<td class="excCodeName">
<code>
<del class="diff-old">MULTIPLE_DATATYPES
</del>
<ins class="diff-chg">LOAD_ERROR
</ins>
</code>
</td>
<td class="excCodeDesc">
There
<del class="diff-old">is
more
than
one
target
datatype
specified
for
</del>
<ins class="diff-chg">was
</ins>
a
<del class="diff-old">single
property
in
the
list
of
coercion
rules.
This
means
that
the
processor
does
not
know
what
the
developer
intended
for
the
target
datatype
for
</del>
<ins class="diff-chg">problem
encountered
loading
</ins>
a
<del class="diff-old">property.
</del>
<ins class="diff-chg">remote
context.
</ins>
</td>
</tr>
</table>
</td>
</tr>
</table>
<div>
<em>
Return
type:
</em>
<code>
<a>
object
</a>
</code>
</div>
</dd>
<dt id="widl-JsonLdProcessor-frame-object-object-input-object-frame-object-options">
<code>
frame
</code>
</dt>
<dd>
<a href="#framing">
Frames
</a>
the
given
<code>
input
</code>
using
the
<code>
frame
</code>
according
to
the
steps
in
the
<a href="#framing-algorithm">
Framing
Algorithm
</a>.
The
<code>
input
</code>
is
used
to
build
the
framed
output
and
is
returned
if
there
are
no
errors.
If
there
are
no
matches
for
the
frame,
<code>
null
</code>
<em class="rfc2119" title="must">
must
</em>
be
returned.
Exceptions
<em class="rfc2119" title="must">
must
</em>
be
thrown
if
there
are
errors.
<table class="parameters">
<tr>
<th>
Parameter
</th>
<th>
Type
</th>
<th>
Nullable
</th>
<th>
Optional
</th>
<th>
Description
</th>
</tr>
<tr>
<td class="prmName">
input
</td>
<td class="prmType">
<code>
<a>
object
</a>
</code>
</td>
<td class="prmNullFalse">
<del class="diff-old">✘
</del>
<ins class="diff-chg">&#10008;
</ins>
</td>
<td class="prmOptFalse">
<del class="diff-old">✘
</del>
<ins class="diff-chg">&#10008;
</ins>
</td>
<td class="prmDesc">
The
JSON-LD
object
to
perform
framing
on.
</td>
</tr>
<tr>
<td class="prmName">
frame
</td>
<td class="prmType">
<code>
<a>
object
</a>
</code>
</td>
<td class="prmNullFalse">
<del class="diff-old">✘
</del>
<ins class="diff-chg">&#10008;
</ins>
</td>
<td class="prmOptFalse">
<del class="diff-old">✘
</del>
<ins class="diff-chg">&#10008;
</ins>
</td>
<td class="prmDesc">
The
frame
to
use
when
re-arranging
the
data.
</td>
</tr>
<tr>
<td class="prmName">
options
</td>
<td class="prmType">
<code>
<a>
object
</a>
</code>
</td>
<td class="prmNullFalse">
<del class="diff-old">✘
</del>
<ins class="diff-chg">&#10008;
</ins>
</td>
<td class="prmOptFalse">
<del class="diff-old">✘
</del>
<ins class="diff-chg">&#10008;
</ins>
</td>
<td class="prmDesc">
A
set
of
options
that
will
affect
the
framing
algorithm.
</td>
</tr>
</table>
<table class="exceptions">
<tr>
<th>
Exception
</th>
<th>
Description
</th>
</tr>
<tr>
<td class="excName">
<a>
InvalidFrame
</a>
</td>
<td class="excDesc">
<table class="exceptionCodes">
<tr>
<td class="excCodeName">
<code>
INVALID_SYNTAX
</code>
</td>
<td class="excCodeDesc">
A
frame
must
be
either
an
object
or
an
array
of
objects,
if
the
frame
is
neither
of
these
types,
this
exception
is
thrown.
</td>
</tr>
<tr>
<td class="excCodeName">
<code>
MULTIPLE_EMBEDS
</code>
</td>
<td class="excCodeDesc">
A
subject
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
was
specified
in
more
than
one
place
in
the
input
frame.
More
than
one
embed
of
a
given
subject
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
is
not
allowed,
and
if
requested,
<em class="rfc2119" title="must">
must
</em>
result
in
this
exception.
</td>
</tr>
</table>
</td>
</tr>
</table>
<div>
<em>
Return
type:
</em>
<code>
<a>
object
</a>
</code>
</div>
</dd>
<dt id="widl-JsonLdProcessor-normalize-DOMString-object-input-object-context">
<code>
normalize
</code>
</dt>
<dd>
<a href="#normalization">
Normalizes
</a>
the
given
<code>
input
</code>
according
to
the
steps
in
the
<a href="#normalization-algorithm">
Normalization
Algorithm
</a>.
The
<code>
input
</code>
<em class="rfc2119" title="must">
must
</em>
be
copied,
normalized
and
returned
if
there
are
no
errors.
If
the
compaction
fails,
<code>
null
</code>
<em class="rfc2119" title="must">
must
</em>
be
returned.
<ins class="diff-new">The
output
is
the
serialized
representation
returned
from
the
</ins><a href="#normalization-algorithm"><ins class="diff-new">
Normalization
Algorithm
</ins></a>.<span class="issue"><ins class="diff-new">
It's
still
an
open
question
if
the
result
is
a
DOMString
representing
the
serialized
graph
in
JSON-LD,
or
an
</ins><a class="tref internalDFN" title="array" href="#dfn-array"><ins class="diff-new">
array
</ins></a><ins class="diff-new">
representation
which
is
in
normalized
form.
</ins></span>
<table class="parameters">
<tr>
<th>
Parameter
</th>
<th>
Type
</th>
<th>
Nullable
</th>
<th>
Optional
</th>
<th>
Description
</th>
</tr>
<tr>
<td class="prmName">
input
</td>
<td class="prmType">
<code>
<a>
object
</a>
</code>
</td>
<td class="prmNullFalse">
<del class="diff-old">✘
</del>
<ins class="diff-chg">&#10008;
</ins>
</td>
<td class="prmOptFalse">
<del class="diff-old">✘
</del>
<ins class="diff-chg">&#10008;
</ins>
</td>
<td class="prmDesc">
The
JSON-LD
object
to
perform
normalization
upon.
</td>
</tr>
<tr>
<td class="prmName">
context
</td>
<td class="prmType">
<code>
<a>
object
</a>
</code>
</td>
<td class="prmNullTrue">
<del class="diff-old">✔
</del>
<ins class="diff-chg">&#10004;
</ins>
</td>
<td class="prmOptTrue">
<del class="diff-old">✔
</del>
<ins class="diff-chg">&#10004;
</ins>
</td>
<td class="prmDesc">
An
external
context
to
use
additionally
to
the
context
embedded
in
<code>
input
</code>
when
expanding
the
<code>
input
</code>.
</td>
</tr>
</table>
<table class="exceptions">
<tr>
<th>
Exception
</th>
<th>
Description
</th>
</tr>
<tr>
<td class="excName">
<a>
InvalidContext
</a>
</td>
<td class="excDesc">
<table class="exceptionCodes">
<tr>
<td class="excCodeName">
<code>
INVALID_SYNTAX
</code>
</td>
<td class="excCodeDesc">
A
general
syntax
error
was
detected
in
the
<code>
@context
</code>.
For
example,
if
a
<code>
<del class="diff-old">@coerce
</del>
<ins class="diff-chg">@type
</ins>
</code>
key
maps
to
anything
other
than
<del class="diff-old">a
string
</del>
<code>
<ins class="diff-chg">@id
</ins></code>
or
an
<del class="diff-old">array
of
strings,
</del>
<ins class="diff-chg">absolute
</ins><abbr title="Internationalized Resource Identifier"><ins class="diff-chg">
IRI
</ins></abbr>,
this
exception
would
be
raised.
</td>
</tr>
<tr>
<td class="excCodeName">
<code>
<del class="diff-old">MULTIPLE_DATATYPES
</del>
<ins class="diff-chg">LOAD_ERROR
</ins>
</code>
</td>
<td class="excCodeDesc">
There
<del class="diff-old">is
more
than
one
target
datatype
specified
for
</del>
<ins class="diff-chg">was
</ins>
a
<del class="diff-old">single
property
in
the
list
of
coercion
rules.
This
means
that
the
processor
does
not
know
what
the
developer
intended
for
the
target
datatype
for
</del>
<ins class="diff-chg">problem
encountered
loading
</ins>
a
<del class="diff-old">property.
</del>
<ins class="diff-chg">remote
context.
</ins>
</td>
</tr>
</table>
</td>
</tr>
</table>
<div>
<em>
Return
type:
</em>
<code>
<a>
<del class="diff-old">object
</del>
<ins class="diff-chg">DOMString
</ins>
</a>
</code>
</div>
</dd>
<dt id="widl-JsonLdProcessor-triples-void-object-input-JsonLdTripleCallback-tripleCallback-object-context">
<code>
triples
</code>
</dt>
<dd>
Processes
the
<code>
input
</code>
according
to
the
<a href="#rdf-conversion-algorithm">
RDF
Conversion
Algorithm
</a>,
calling
the
provided
<code>
tripleCallback
</code>
for
each
triple
generated.
<table class="parameters">
<tr>
<th>
Parameter
</th>
<th>
Type
</th>
<th>
Nullable
</th>
<th>
Optional
</th>
<th>
Description
</th>
</tr>
<tr>
<td class="prmName">
input
</td>
<td class="prmType">
<code>
<a>
object
</a>
</code>
</td>
<td class="prmNullFalse">
<del class="diff-old">✘
</del>
<ins class="diff-chg">&#10008;
</ins>
</td>
<td class="prmOptFalse">
<del class="diff-old">✘
</del>
<ins class="diff-chg">&#10008;
</ins>
</td>
<td class="prmDesc">
The
JSON-LD
object
to
process
when
outputting
triples.
</td>
</tr>
<tr>
<td class="prmName">
tripleCallback
</td>
<td class="prmType">
<code>
<a href="#idl-def-JsonLdTripleCallback" class="idlType">
<code>
JsonLdTripleCallback
</code>
</a>
</code>
</td>
<td class="prmNullFalse">
<del class="diff-old">✘
</del>
<ins class="diff-chg">&#10008;
</ins>
</td>
<td class="prmOptFalse">
<del class="diff-old">✘
</del>
<ins class="diff-chg">&#10008;
</ins>
</td>
<td class="prmDesc">
A
callback
that
is
called
whenever
a
processing
error
occurs
on
the
given
<code>
input
</code>.
<div class="issue">
This
callback
should
be
aligned
with
the
RDF
API.
</div>
</td>
</tr>
<tr>
<td class="prmName">
context
</td>
<td class="prmType">
<code>
<a>
object
</a>
</code>
</td>
<td class="prmNullTrue">
<del class="diff-old">✔
</del>
<ins class="diff-chg">&#10004;
</ins>
</td>
<td class="prmOptTrue">
<del class="diff-old">✔
</del>
<ins class="diff-chg">&#10004;
</ins>
</td>
<td class="prmDesc">
An
external
context
to
use
additionally
to
the
context
embedded
in
<code>
input
</code>
when
expanding
the
<code>
input
</code>.
</td>
</tr>
</table>
<table class="exceptions">
<tr>
<th>
Exception
</th>
<th>
Description
</th>
</tr>
<tr>
<td class="excName">
<a>
InvalidContext
</a>
</td>
<td class="excDesc">
<table class="exceptionCodes">
<tr>
<td class="excCodeName">
<code>
INVALID_SYNTAX
</code>
</td>
<td class="excCodeDesc">
A
general
syntax
error
was
detected
in
the
<code>
@context
</code>.
For
example,
if
a
<code>
<del class="diff-old">@coerce
</del>
<ins class="diff-chg">@type
</ins>
</code>
key
maps
to
anything
other
than
<del class="diff-old">a
string
</del>
<code>
<ins class="diff-chg">@id
</ins></code>
or
an
<del class="diff-old">array
of
strings,
</del>
<ins class="diff-chg">absolute
</ins><abbr title="Internationalized Resource Identifier"><ins class="diff-chg">
IRI
</ins></abbr>,
this
exception
would
be
raised.
</td>
</tr>
<tr>
<td class="excCodeName">
<code>
<del class="diff-old">MULTIPLE_DATATYPES
</del>
<ins class="diff-chg">LOAD_ERROR
</ins>
</code>
</td>
<td class="excCodeDesc">
There
<del class="diff-old">is
more
than
one
target
datatype
specified
for
</del>
<ins class="diff-chg">was
</ins>
a
<del class="diff-old">single
property
in
the
list
of
coercion
rules.
This
means
that
the
processor
does
not
know
what
the
developer
intended
for
the
target
datatype
for
</del>
<ins class="diff-chg">problem
encountered
loading
</ins>
a
<del class="diff-old">property.
</del>
<ins class="diff-chg">remote
context.
</ins>
</td>
</tr>
</table>
</td>
</tr>
</table>
<div>
<em>
Return
type:
</em>
<code>
<a>
<del class="diff-old">object
</del>
<ins class="diff-chg">void
</ins>
</a>
</code>
</div>
</dd>
</dl>
</div>
</div>
<div id="jsonldtriplecallback" class="section">
<h3>
<span class="secno">
2.2
</span>
JsonLdTripleCallback
</h3>
<p>
The
JsonLdTripleCallback
is
called
whenever
the
processor
generates
a
triple
during
the
<code>
triple()
</code>
call.
</p>
<del class="diff-old">]
interface  {
};
</del>
    <pre class="idl"><span class="idlInterface" id="idl-def-JsonLdTripleCallback">[<span class="extAttr">NoInterfaceObject Callback</span>]
<ins class="diff-chg">interface <span class="idlInterfaceID">JsonLdTripleCallback</span> {
</ins><span class="idlMethod">    <span class="idlMethType"><a>void</a></span> <span class="idlMethName"><a href="#widl-JsonLdTripleCallback-triple-void-DOMString-subject-DOMString-property-DOMString-objectType-DOMString-object-DOMString-datatype-DOMString-language">triple</a></span> (<span class="idlParam"><span class="idlParamType"><a>DOMString</a></span> <span class="idlParamName">subject</span></span>, <span class="idlParam"><span class="idlParamType"><a>DOMString</a></span> <span class="idlParamName">property</span></span>, <span class="idlParam"><span class="idlParamType"><a>DOMString</a></span> <span class="idlParamName">objectType</span></span>, <span class="idlParam"><span class="idlParamType"><a>DOMString</a></span> <span class="idlParamName">object</span></span>, <span class="idlParam"><span class="idlParamType"><a>DOMString</a>?</span> <span class="idlParamName">datatype</span></span>, <span class="idlParam"><span class="idlParamType"><a>DOMString</a>?</span> <span class="idlParamName">language</span></span>);</span>
<ins class="diff-chg">
};</span>
</ins>
</pre>
<div id="methods-1" class="section">
<h4>
<span class="secno">
2.2.1
</span>
Methods
</h4>
<dl class="methods">
<dt id="widl-JsonLdTripleCallback-triple-void-DOMString-subject-DOMString-property-DOMString-objectType-DOMString-object-DOMString-datatype-DOMString-language">
<code>
triple
</code>
</dt>
<dd>
This
callback
is
invoked
whenever
a
triple
is
generated
by
the
processor.
<table class="parameters">
<tr>
<th>
Parameter
</th>
<th>
Type
</th>
<th>
Nullable
</th>
<th>
Optional
</th>
<th>
Description
</th>
</tr>
<tr>
<td class="prmName">
subject
</td>
<td class="prmType">
<code>
<a>
DOMString
</a>
</code>
</td>
<td class="prmNullFalse">
<del class="diff-old">✘
</del>
<ins class="diff-chg">&#10008;
</ins>
</td>
<td class="prmOptFalse">
<del class="diff-old">✘
</del>
<ins class="diff-chg">&#10008;
</ins>
</td>
<td class="prmDesc">
The
subject
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
that
is
associated
with
the
triple.
</td>
</tr>
<tr>
<td class="prmName">
property
</td>
<td class="prmType">
<code>
<a>
DOMString
</a>
</code>
</td>
<td class="prmNullFalse">
<del class="diff-old">✘
</del>
<ins class="diff-chg">&#10008;
</ins>
</td>
<td class="prmOptFalse">
<del class="diff-old">✘
</del>
<ins class="diff-chg">&#10008;
</ins>
</td>
<td class="prmDesc">
The
property
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
that
is
associated
with
the
triple.
</td>
</tr>
<tr>
<td class="prmName">
objectType
</td>
<td class="prmType">
<code>
<a>
DOMString
</a>
</code>
</td>
<td class="prmNullFalse">
<del class="diff-old">✘
</del>
<ins class="diff-chg">&#10008;
</ins>
</td>
<td class="prmOptFalse">
<del class="diff-old">✘
</del>
<ins class="diff-chg">&#10008;
</ins>
</td>
<td class="prmDesc">
The
type
of
object
that
is
associated
with
the
triple.
Valid
values
are
<code>
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
</code>
and
<code>
literal
</code>.
</td>
</tr>
<tr>
<td class="prmName">
object
</td>
<td class="prmType">
<code>
<a>
DOMString
</a>
</code>
</td>
<td class="prmNullFalse">
<del class="diff-old">✘
</del>
<ins class="diff-chg">&#10008;
</ins>
</td>
<td class="prmOptFalse">
<del class="diff-old">✘
</del>
<ins class="diff-chg">&#10008;
</ins>
</td>
<td class="prmDesc">
The
object
value
associated
with
the
subject
and
the
property.
</td>
</tr>
<tr>
<td class="prmName">
datatype
</td>
<td class="prmType">
<code>
<a>
DOMString
</a>
</code>
</td>
<td class="prmNullTrue">
<del class="diff-old">✔
</del>
<ins class="diff-chg">&#10004;
</ins>
</td>
<td class="prmOptFalse">
<del class="diff-old">✘
</del>
<ins class="diff-chg">&#10008;
</ins>
</td>
<td class="prmDesc">
The
datatype
associated
with
the
object.
</td>
</tr>
<tr>
<td class="prmName">
language
</td>
<td class="prmType">
<code>
<a>
DOMString
</a>
</code>
</td>
<td class="prmNullTrue">
<del class="diff-old">✔
</del>
<ins class="diff-chg">&#10004;
</ins>
</td>
<td class="prmOptFalse">
<del class="diff-old">✘
</del>
<ins class="diff-chg">&#10008;
</ins>
</td>
<td class="prmDesc">
The
language
associated
with
the
object
in
BCP47
format.
</td>
</tr>
</table>
<div>
<em>
No
exceptions.
</em>
</div>
<div>
<em>
Return
type:
</em>
<code>
<a>
void
</a>
</code>
</div>
</dd>
</dl>
</div>
</div>
</div>
<div id="algorithms" class="section">
<h2>
<span class="secno">
3.
</span>
Algorithms
</h2>
<p>
All
algorithms
described
in
this
section
are
intended
to
operate
on
language-native
data
structures.
That
is,
the
serialization
to
a
text-based
JSON
document
isn't
required
as
input
or
output
to
any
of
these
algorithms
and
language-native
data
structures
<em class="rfc2119" title="must">
must
</em>
be
used
where
applicable.
</p>
<div id="syntax-tokens-and-keywords" class="section">
<h3>
<span class="secno">
3.1
</span>
Syntax
Tokens
and
Keywords
</h3>
<p>
JSON-LD
specifies
a
number
of
syntax
tokens
and
<del class="diff-old">keywords
</del>
<dfn title="keyword" id="dfn-keyword">
<ins class="diff-chg">keyword
</ins></dfn><ins class="diff-chg">
s
</ins>
that
are
using
in
all
algorithms
described
in
this
section:
</p>
<dl>
<dt>
<code>
@context
</code>
</dt>
<dd>
Used
to
set
the
<a class="tref internalDFN" title="local_context" href="#dfn-local_context">
local
context
</a>.
</dd>
<dt>
<code>
<del class="diff-old">@base
</del>
<ins class="diff-chg">@id
</ins>
</code>
</dt>
<dd>
<del class="diff-old">Used
to
set
the
base
IRI
for
all
object
IRIs
affected
by
</del>
<ins class="diff-chg">Sets
</ins>
the
active
<del class="diff-old">context
.
</del>
<ins class="diff-chg">subject.
</ins>
</dd>
<dt>
<code>
<del class="diff-old">@vocab
</del>
<ins class="diff-chg">@language
</ins>
</code>
</dt>
<dd>
Used
to
<del class="diff-old">set
</del>
<ins class="diff-chg">specify
</ins>
the
<del class="diff-old">base
IRI
</del>
<ins class="diff-chg">language
</ins>
for
<del class="diff-old">all
property
IRIs
affected
by
the
active
context
.
@coerce
Used
to
specify
type
coercion
rules.
@literal
Used
to
specify
</del>
a
<del class="diff-old">literal
value.
@iri
Used
to
specify
an
IRI
value.
</del>
<ins class="diff-chg">literal.
</ins>
</dd>
<dt>
<code>
<del class="diff-old">@language
</del>
<ins class="diff-chg">@type
</ins>
</code>
</dt>
<dd>
Used
to
<del class="diff-old">specify
</del>
<ins class="diff-chg">set
</ins>
the
<del class="diff-old">language
for
</del>
<ins class="diff-chg">type
of
the
active
subject
or
the
datatype
of
</ins>
a
literal.
</dd>
<dt>
<code>
<del class="diff-old">@datatype
</del>
<ins class="diff-chg">@value
</ins>
</code>
</dt>
<dd>
Used
to
specify
the
<del class="diff-old">datatype
for
</del>
<ins class="diff-chg">value
of
</ins>
a
literal.
</dd>
<dt>
<code>:
</code>
</dt>
<dd>
The
separator
for
JSON
keys
and
values
that
use
the
<a class="tref internalDFN" title="prefix" href="#dfn-prefix">
prefix
</a>
mechanism.
</dd>
<del class="diff-old">@subject
Sets
the
active
subject.
@type
Used
to
set
the
type
of
the
active
subject.
</del>
</dl>
<p>
<ins class="diff-new">All
JSON-LD
tokens
and
keywords
are
case-sensitive.
</ins></p>
</div>
<div id="algorithm-terms" class="section">
<h3>
<span class="secno">
3.2
</span>
Algorithm
Terms
</h3>
<dl>
<dt>
<dfn title="initial_context" id="dfn-initial_context">
initial
context
</dfn>
</dt>
<dd>
a
context
that
is
specified
to
the
algorithm
before
processing
begins.
<ins class="diff-new">The
contents
of
the
initial
context
is
defined
in
</ins><a href="#appendix-b"><ins class="diff-new">
Appendix
B
</ins></a>.
</dd>
<dt>
<dfn title="active_subject" id="dfn-active_subject">
active
subject
</dfn>
</dt>
<dd>
the
currently
active
subject
that
the
processor
should
use
when
processing.
</dd>
<dt>
<dfn title="active_property" id="dfn-active_property">
active
property
</dfn>
</dt>
<dd>
the
currently
active
property
that
the
processor
should
use
when
processing.
</dd>
<dt>
<dfn title="active_object" id="dfn-active_object">
active
object
</dfn>
</dt>
<dd>
the
currently
active
object
that
the
processor
should
use
when
processing.
</dd>
<dt>
<dfn title="active_context" id="dfn-active_context">
active
context
</dfn>
</dt>
<dd>
a
context
that
is
used
to
resolve
<a class="tref internalDFN" title="term" href="#dfn-term">
term
</a>
s
while
the
processing
algorithm
is
running.
The
<a class="tref internalDFN" title="active_context" href="#dfn-active_context">
active
context
</a>
is
the
context
contained
within
the
<a class="tref internalDFN" title="processor_state" href="#dfn-processor_state">
processor
state
</a>.
</dd>
<dt>
<dfn title="blank_node" id="dfn-blank_node">
<ins class="diff-new">blank
node
</ins></dfn></dt><dd><ins class="diff-new">
a
blank
node
is
a
</ins><a class="tref internalDFN" title="resource" href="#dfn-resource"><ins class="diff-new">
resource
</ins></a><ins class="diff-new">
which
is
neither
an
</ins><a class="tref internalDFN" title="iri" href="#dfn-iri"><abbr title="Internationalized Resource Identifier"><ins class="diff-new">
IRI
</ins></abbr></a><ins class="diff-new">
nor
a
</ins><a class="tref internalDFN" title="literal" href="#dfn-literal"><ins class="diff-new">
literal
</ins></a>.<ins class="diff-new">
Blank
nodes
may
be
named
or
unnamed
and
often
take
on
the
role
of
a
variable
that
may
represent
either
an
</ins><a class="tref internalDFN" title="iri" href="#dfn-iri"><abbr title="Internationalized Resource Identifier"><ins class="diff-new">
IRI
</ins></abbr></a><ins class="diff-new">
or
a
</ins><a class="tref internalDFN" title="literal" href="#dfn-literal"><ins class="diff-new">
literal
</ins></a>.</dd><dt>
<dfn title="local_context" id="dfn-local_context">
local
context
</dfn>
</dt>
<dd>
a
context
that
is
specified
within
a
<a class="tref internalDFN" title="json_object" href="#dfn-json_object">
JSON
object
</a>,
specified
via
the
<code>
@context
</code>
<del class="diff-old">keyword.
</del>
<a class="tref internalDFN" title="keyword" href="#dfn-keyword">
<ins class="diff-chg">keyword
</ins></a>.
</dd>
<dt>
<dfn title="processor_state" id="dfn-processor_state">
processor
state
</dfn>
</dt>
<dd>
the
<a class="tref internalDFN" title="processor_state" href="#dfn-processor_state">
processor
state
</a>,
which
includes
the
<a class="tref internalDFN" title="active_context" href="#dfn-active_context">
active
context
</a>,
<a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">
active
subject
</a>,
and
<a class="tref internalDFN" title="active_property" href="#dfn-active_property">
active
property
</a>.
The
<a class="tref internalDFN" title="processor_state" href="#dfn-processor_state">
processor
state
</a>
is
managed
as
a
stack
with
elements
from
the
previous
<a class="tref internalDFN" title="processor_state" href="#dfn-processor_state">
processor
state
</a>
copied
into
a
new
<a class="tref internalDFN" title="processor_state" href="#dfn-processor_state">
processor
state
</a>
when
entering
a
new
<a class="tref internalDFN" title="json_object" href="#dfn-json_object">
JSON
object
</a>.
</dd>
<dt>
<dfn title="json-ld_input" id="dfn-json-ld_input">
JSON-LD
input
</dfn>
</dt>
<dd>
The
JSON-LD
data
structure
that
is
provided
as
input
to
the
algorithm.
</dd>
<dt>
<dfn title="json-ld_output" id="dfn-json-ld_output">
JSON-LD
output
</dfn>
</dt>
<dd>
The
JSON-LD
data
structure
that
is
produced
as
output
by
the
algorithm.
</dd>
<dt>
<dfn title="term" id="dfn-term">
term
</dfn>
</dt>
<dd>
A
<a class="tref internalDFN" title="term" href="#dfn-term">
term
</a>
is
a
short
word
defined
with
a
<a href="#context">
context
</a>
that
<em class="rfc2119" title="may">
may
</em>
be
expanded
to
an
<a class="tref internalDFN" title="iri" href="#dfn-iri">
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
</a>
</dd>
<dt>
<dfn title="prefix" id="dfn-prefix">
prefix
</dfn>
</dt>
<dd>
A
<a class="tref internalDFN" title="prefix" href="#dfn-prefix">
prefix
</a>
is
a
<a class="tref internalDFN" title="term" href="#dfn-term">
term
</a>
that
expands
to
a
Web
Vocabulary
base
<del class="diff-old">IRI.
</del>
<abbr title="Internationalized Resource Identifier">
<ins class="diff-chg">IRI
</ins></abbr>.
It
is
typically
used
along
with
a
<em>
suffix
</em>
to
create
an
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
within
a
Web
Vocabulary.
</dd>
<dt>
<dfn title="plain_literal" id="dfn-plain_literal">
plain
literal
</dfn>
</dt>
<dd>
A
<a class="tref internalDFN" title="plain_literal" href="#dfn-plain_literal">
plain
literal
</a>
is
a
<a class="tref internalDFN" title="literal" href="#dfn-literal">
literal
</a>
without
a
datatype,
possibly
including
a
language.
</dd>
<dt>
<dfn title="typed_literal" id="dfn-typed_literal">
typed
literal
</dfn>
</dt>
<dd>
A
<a class="tref internalDFN" title="typed_literal" href="#dfn-typed_literal">
typed
literal
</a>
is
a
<a class="tref internalDFN" title="literal" href="#dfn-literal">
literal
</a>
with
an
associated
<a class="tref internalDFN" title="iri" href="#dfn-iri">
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
</a>
which
indicates
the
literal's
datatype.
</dd>
</dl>
</div>
<div id="context-1" class="section">
<h3 id="context">
<span class="secno">
3.3
</span>
Context
</h3>
<p>
Processing
of
JSON-LD
data
structure
is
managed
recursively.
During
processing,
each
rule
is
applied
using
information
provided
by
the
<a class="tref internalDFN" title="active_context" href="#dfn-active_context">
active
context
</a>.
Processing
begins
by
pushing
a
new
<a class="tref internalDFN" title="processor_state" href="#dfn-processor_state">
processor
state
</a>
onto
the
<a class="tref internalDFN" title="processor_state" href="#dfn-processor_state">
processor
state
</a>
stack
and
initializing
the
<a class="tref internalDFN" title="active_context" href="#dfn-active_context">
active
context
</a>
with
the
<a class="tref internalDFN" title="initial_context" href="#dfn-initial_context">
initial
context
</a>.
If
a
<a class="tref internalDFN" title="local_context" href="#dfn-local_context">
local
context
</a>
is
encountered,
information
from
the
<a class="tref internalDFN" title="local_context" href="#dfn-local_context">
local
context
</a>
is
merged
into
the
<a class="tref internalDFN" title="active_context" href="#dfn-active_context">
active
context
</a>.
</p>
<p>
The
<a class="tref internalDFN" title="active_context" href="#dfn-active_context">
active
context
</a>
is
used
for
expanding
keys
and
values
of
a
<a class="tref internalDFN" title="json_object" href="#dfn-json_object">
JSON
object
</a>
(or
elements
of
a
list
(see
<span a="#list-processing">
List
Processing
</span>
<del class="diff-old">)).
</del>
<ins class="diff-chg">))
using
a
</ins><dfn title="term_mapping" id="dfn-term_mapping"><ins class="diff-chg">
term
mapping
</ins></dfn>.<ins class="diff-chg">
It
is
also
used
to
maintain
</ins><dfn title="coercion_mapping" id="dfn-coercion_mapping"><ins class="diff-chg">
coercion
mapping
</ins></dfn><ins class="diff-chg">
s
from
IRIs
associated
with
terms
to
datatypes,
and
</ins><dfn title="list_mapping" id="dfn-list_mapping"><ins class="diff-chg">
list
mapping
</ins></dfn><ins class="diff-chg">
s
for
IRIs
associated
with
terms.
</ins>
</p>
<p>
A
<a class="tref internalDFN" title="local_context" href="#dfn-local_context">
local
context
</a>
is
identified
within
a
<a class="tref internalDFN" title="json_object" href="#dfn-json_object">
JSON
object
</a>
having
a
key
of
<code>
@context
</code>
with
<a class="tref internalDFN" title="string" href="#dfn-string">
string
</a>,
<a class="tref internalDFN" title="array" href="#dfn-array">
array
</a>
or
a
<a class="tref internalDFN" title="json_object" href="#dfn-json_object">
JSON
object
</a>
value.
When
processing
a
<a class="tref internalDFN" title="local_context" href="#dfn-local_context">
local
context
</a>,
special
processing
rules
apply:
</p>
<ol class="algorithm">
<li>
Create
a
new,
empty
<a class="tref internalDFN" title="local_context" href="#dfn-local_context">
local
context
</a>.
</li>
<li>
Let
<em>
value
</em>
be
the
value
of
<code>
@context
</code>
<ol id="process-context" class="algorithm">
<li>
If
<em>
value
</em>
is
an
<a class="tref internalDFN" title="array" href="#dfn-array">
array
</a>,
process
each
element
as
<em>
value
</em>,
in
order
using
<a href="#process-context">
Step
2
</a>.
</li>
<li>
If
<em>
value
</em>
is
a
simple
<a class="tref internalDFN" title="string" href="#dfn-string">
string
</a>,
it
<em class="rfc2119" title="must">
must
</em>
have
a
lexical
form
of
<del class="diff-old">IRI.
Set
value
to
the
result
of
performing
</del>
<ins class="diff-chg">absolute
</ins><abbr title="Internationalized Resource Identifier">
IRI
<del class="diff-old">Expansion
on
value
.
</del>
</abbr>.
<ol class="algorithm">
<li>
<del class="diff-old">If
value
does
is
not
an
absolute
IRI,
abort
this
processing
step.
Otherwise,
</del>
Dereference
<em>
value
</em>.
</li>
<li>
If
the
resulting
document
is
a
JSON
document,
extract
the
top-level
<code>
@context
</code>
element
using
the
JSON
Pointer
<del class="diff-old">&quot;/@context&quot;
</del>
<ins class="diff-chg">"/@context"
</ins>
as
described
in
[
<cite>
<a class="bibref" rel="biblioentry" href="#bib-JSON-POINTER">
JSON-POINTER
</a>
</cite>
].
Set
<em>
value
</em>
to
the
extracted
content,
or
an
empty
<a class="tref internalDFN" title="json_object" href="#dfn-json_object">
JSON
Object
</a>
if
no
value
exists.
</li>
<li>
<ins class="diff-new">Merge
the
of
</ins><a class="tref internalDFN" title="local_context" href="#dfn-local_context"><ins class="diff-new">
local
context
</ins></a><ins class="diff-new">
into
the
</ins><a class="tref internalDFN" title="active_context" href="#dfn-active_context"><ins class="diff-new">
active
context
</ins></a>.</li></ol></li>
</ol>
</li>
<li>
If
<em>
value
</em>
is
a
<a class="tref internalDFN" title="json_object" href="#dfn-json_object">
JSON
object
</a>,
perform
the
following
steps:
<ol class="algorithm">
<li>
If
<em>
value
</em>
has
a
<code>
<del class="diff-old">@base
</del>
<ins class="diff-chg">@language
</ins>
</code>
key,
it
<em class="rfc2119" title="must">
must
</em>
have
a
value
of
a
simple
<a class="tref internalDFN" title="string" href="#dfn-string">
string
</a>
<del class="diff-old">with
the
lexical
form
of
an
absolute
IRI.
</del>
<ins class="diff-chg">or
</ins><code><ins class="diff-chg">
null
</ins></code>.
Add
the
<del class="diff-old">base
mapping
</del>
<ins class="diff-chg">language
</ins>
to
the
<a class="tref internalDFN" title="local_context" href="#dfn-local_context">
local
context
</a>.
<del class="diff-old">Turtle
allows
@base
to
be
relative.
If
we
did
this,
we
would
have
to
add
IRI
Expansion
.
</del>
</li>
<li>
<del class="diff-old">If
</del>
<ins class="diff-chg">Otherwise,
for
each
key
in
</ins>
<em>
value
</em>
<del class="diff-old">has
a
@vocab
key,
it
must
have
a
value
</del>
<ins class="diff-chg">having
the
lexical
form
</ins>
of
<cite>
<a href="http://www.w3.org/TR/2009/REC-xml-names-20091208/#NT-NCName">
<ins class="diff-new">NCName
</ins></a></cite><ins class="diff-new">
(see
[
</ins><cite><a class="bibref" rel="biblioentry" href="#bib-XML-NAMES"><ins class="diff-new">
XML-NAMES
</ins></a></cite><ins class="diff-new">
]),
or
is
an
empty
string,
</ins><ol class="algorithm"><li><ins class="diff-new">
If
the
key's
value
is
</ins>
a
simple
<a class="tref internalDFN" title="string" href="#dfn-string">
string
<del class="diff-old">with
</del>
</a>,
<ins class="diff-chg">the
value
</ins><em class="rfc2119" title="must"><ins class="diff-chg">
must
</ins></em><ins class="diff-chg">
have
</ins>
the
<del class="diff-old">lexical
</del>
form
of
<del class="diff-old">an
</del>
<a class="tref internalDFN" title="term" href="#dfn-term">
<ins class="diff-chg">term
</ins></a>,<a class="tref internalDFN" title="prefix" href="#dfn-prefix"><ins class="diff-chg">
prefix
</ins></a>:suffix,
absolute
<del class="diff-old">IRI.
Add
</del>
<abbr title="Internationalized Resource Identifier">
<ins class="diff-chg">IRI
</ins></abbr>.<ins class="diff-chg">
Determine
</ins>
the
<del class="diff-old">vocabulary
</del>
<abbr title="Internationalized Resource Identifier">
<ins class="diff-chg">IRI
</ins></abbr>
mapping
<del class="diff-old">to
the
local
context
after
</del>
<ins class="diff-chg">value
by
</ins>
performing
<a href="#iri-expansion">
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
Expansion
</a>
on
the
associated
value.
<ins class="diff-new">If
the
result
of
the
</ins><abbr title="Internationalized Resource Identifier"><ins class="diff-new">
IRI
</ins></abbr><ins class="diff-new">
mapping
is
an
absolute
</ins><abbr title="Internationalized Resource Identifier"><ins class="diff-new">
IRI
</ins></abbr>,<ins class="diff-new">
merge
the
key-value
pair
into
the
</ins><a class="tref internalDFN" title="local_context" href="#dfn-local_context"><ins class="diff-new">
local
context
</ins></a><a class="tref internalDFN" title="term_mapping" href="#dfn-term_mapping"><ins class="diff-new">
term
mapping
</ins></a>.
</li>
<li id="object-context">
<ins class="diff-new">Otherwise,
the
key's
value
</ins><em class="rfc2119" title="must"><ins class="diff-new">
must
</ins></em><ins class="diff-new">
be
a
</ins><a class="tref internalDFN" title="json_object" href="#dfn-json_object"><ins class="diff-new">
JSON
object
</ins></a>.<ol class="algorithm">
<li>
<del class="diff-old">If
</del>
<ins class="diff-chg">The
</ins>
value
<em class="rfc2119" title="must">
<ins class="diff-new">must
</ins>
</em>
<del class="diff-old">has
</del>
<ins class="diff-chg">have
</ins>
a
<code>
<del class="diff-old">@coerce
</del>
<ins class="diff-chg">@id
</ins>
</code>
<del class="diff-old">key,
it
</del>
<ins class="diff-chg">key
with
a
string
value,
the
value
</ins>
<em class="rfc2119" title="must">
must
</em>
have
<del class="diff-old">a
value
</del>
<ins class="diff-chg">the
form
</ins>
of
<del class="diff-old">a
JSON
object
.
Add
</del>
<a class="tref internalDFN" title="term" href="#dfn-term">
<ins class="diff-chg">term
</ins></a>,<a class="tref internalDFN" title="prefix" href="#dfn-prefix"><ins class="diff-chg">
prefix
</ins></a>:suffix,<ins class="diff-chg">
absolute
</ins><abbr title="Internationalized Resource Identifier"><ins class="diff-chg">
IRI
</ins></abbr>.<ins class="diff-chg">
Determine
</ins>
the
<del class="diff-old">@coerce
</del>
<abbr title="Internationalized Resource Identifier">
<ins class="diff-chg">IRI
</ins></abbr>
mapping
<del class="diff-old">to
the
local
context
</del>
<ins class="diff-chg">value
by
</ins>
performing
<a href="#iri-expansion">
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
Expansion
</a>
on
the
associated
<del class="diff-old">value(s).
</del>
<ins class="diff-chg">value.
If
the
result
of
the
</ins><abbr title="Internationalized Resource Identifier"><ins class="diff-chg">
IRI
</ins></abbr><ins class="diff-chg">
mapping
is
an
absolute
</ins><abbr title="Internationalized Resource Identifier"><ins class="diff-chg">
IRI
</ins></abbr>,<ins class="diff-chg">
merge
the
key-value
pair
into
the
</ins><a class="tref internalDFN" title="local_context" href="#dfn-local_context"><ins class="diff-chg">
local
context
</ins></a><a class="tref internalDFN" title="term_mapping" href="#dfn-term_mapping"><ins class="diff-chg">
term
mapping
</ins></a>.
</li>
<li>
If
<ins class="diff-chg">the
</ins>
value
has
a
<code>
<del class="diff-old">@language
</del>
<ins class="diff-chg">@type
</ins>
</code>
key,
<del class="diff-old">it
</del>
<ins class="diff-chg">the
value
</ins>
<em class="rfc2119" title="must">
must
</em>
have
<del class="diff-old">a
value
</del>
<ins class="diff-chg">the
form
</ins>
of
<del class="diff-old">a
simple
string
</del>
<a class="tref internalDFN" title="term" href="#dfn-term">
<ins class="diff-chg">term
</ins></a>,<a class="tref internalDFN" title="prefix" href="#dfn-prefix"><ins class="diff-chg">
prefix
</ins></a>:suffix,<ins class="diff-chg">
absolute
</ins><abbr title="Internationalized Resource Identifier"><ins class="diff-chg">
IRI
</ins></abbr>
or
<ins class="diff-new">the
</ins><a class="tref internalDFN" title="keyword" href="#dfn-keyword"><ins class="diff-new">
keyword
</ins></a>
<code>
<del class="diff-old">null
</del>
<ins class="diff-chg">@id
</ins>
</code>.
<del class="diff-old">Add
</del>
<ins class="diff-chg">Determine
</ins>
the
<del class="diff-old">language
to
</del>
<abbr title="Internationalized Resource Identifier">
<ins class="diff-chg">IRI
</ins></abbr><ins class="diff-chg">
by
performing
</ins><a href="#iri-expansion"><abbr title="Internationalized Resource Identifier"><ins class="diff-chg">
IRI
</ins></abbr><ins class="diff-chg">
Expansion
</ins></a><ins class="diff-chg">
on
the
associated
value.
If
the
result
of
the
</ins><abbr title="Internationalized Resource Identifier"><ins class="diff-chg">
IRI
</ins></abbr><ins class="diff-chg">
mapping
is
an
absolute
</ins><abbr title="Internationalized Resource Identifier"><ins class="diff-chg">
IRI
</ins></abbr><ins class="diff-chg">
or
</ins><code><ins class="diff-chg">
@id
</ins></code>,<ins class="diff-chg">
merge
into
</ins>
the
<a class="tref internalDFN" title="local_context" href="#dfn-local_context">
local
context
</a>
<a class="tref internalDFN" title="coercion_mapping" href="#dfn-coercion_mapping">
<ins class="diff-new">coercion
mapping
</ins>
</a>.
</li>
<li>
<del class="diff-old">Otherwise,
for
each
key
in
</del>
<ins class="diff-chg">If
the
</ins>
value
<del class="diff-old">having
</del>
<ins class="diff-chg">has
a
</ins><code><ins class="diff-chg">
@list
</ins></code><ins class="diff-chg">
key,
</ins>
the
<del class="diff-old">lexical
form
of
NCName
,
it's
</del>
value
<em class="rfc2119" title="must">
must
</em>
<del class="diff-old">have
</del>
be
<del class="diff-old">a
simple
string
with
the
lexical
form
of
IRI.
</del>
<code>
<ins class="diff-chg">true
</ins></code><ins class="diff-chg">
or
</ins><code><ins class="diff-chg">
false
</ins></code>.
Merge
<del class="diff-old">the
key-value
pair
</del>
into
the
<a class="tref internalDFN" title="local_context" href="#dfn-local_context">
local
context
</a>
<a class="tref internalDFN" title="list_mapping" href="#dfn-list_mapping">
<ins class="diff-new">list
mapping
</ins>
</a>.
</li>
</ol>
</li>
<li>
Merge
the
<del class="diff-old">of
</del>
<a class="tref internalDFN" title="local_context" href="#dfn-local_context">
local
context
</a>
<del class="diff-old">'s
@coerce
mapping
</del>
into
the
<a class="tref internalDFN" title="active_context" href="#dfn-active_context">
active
context
<del class="diff-old">'s
@coerce
mapping
as
described
below
</del>
</a>.
</li>
<li>
<del class="diff-old">Merge
all
</del>
<ins class="diff-chg">Repeat
</ins><a href="#object-context"><ins class="diff-chg">
Step
3.2
</ins></a><ins class="diff-chg">
until
no
</ins>
entries
<del class="diff-old">other
than
the
@coerce
mapping
from
</del>
<ins class="diff-chg">are
added
to
</ins>
the
<a class="tref internalDFN" title="local_context" href="#dfn-local_context">
local
context
<del class="diff-old">to
the
active
context
overwriting
any
duplicate
values.
</del>
</a>.
</li>
</ol>
<del class="diff-old">Coerce
Map
each
key-value
pair
in
the
local
context
's
@coerce
mapping
into
the
active
context
's
@coerce
mapping,
overwriting
any
duplicate
values
in
the
active
context
's
@coerce
mapping.
The
@coerce
mapping
has
either
</del>
</li>
</ol>
</li>
</ol>
<p class="note">
<ins class="diff-chg">It
can
be
difficult
to
distinguish
between
</ins>
a
<del class="diff-old">single
</del>
<code>
prefix:suffix
</code>
<del class="diff-old">value,
a
single
term
value
or
an
array
of
prefix:suffix
or
term
values.
When
merging
with
an
existing
mapping
in
the
active
context
,
map
all
term
values
to
array
form
and
replace
with
the
union
of
the
value
from
the
local
context
</del>
and
<del class="diff-old">the
value
of
the
active
context
.
If
the
result
is
</del>
an
<del class="diff-old">array
with
a
single
value,
the
processor
may
represent
this
as
a
string
value.
Initial
Context
The
initial
context
is
initialized
</del>
<ins class="diff-chg">absolute
</ins><abbr title="Internationalized Resource Identifier"><ins class="diff-chg">
IRI
</ins></abbr>,
as
<del class="diff-old">follows:
@base
is
set
using
section
5.1
Establishing
</del>
a
<del class="diff-old">Base
URI
of
[
RFC3986
</del>
<a class="tref internalDFN" title="prefix" href="#dfn-prefix">
<ins class="diff-chg">prefix
</ins>
</a>
<del class="diff-old">].
Processors
</del>
may
<del class="diff-old">provide
</del>
<ins class="diff-chg">seem
to
be
</ins>
a
<del class="diff-old">means
of
setting
the
base
</del>
<ins class="diff-chg">valid
</ins><abbr title="Internationalized Resource Identifier">
IRI
<del class="diff-old">programatically.
@coerce
is
set
with
</del>
</abbr>
<em>
<ins class="diff-chg">scheme
</ins></em>.<ins class="diff-chg">
When
performing
repeated
</ins><abbr title="Internationalized Resource Identifier"><ins class="diff-chg">
IRI
</ins></abbr><ins class="diff-chg">
expansion,
</ins>
a
<del class="diff-old">single
</del>
<ins class="diff-chg">term
used
as
a
prefix
may
not
have
a
valid
</ins>
mapping
<del class="diff-old">from
@iri
</del>
<ins class="diff-chg">due
</ins>
to
<del class="diff-old">@type
.
</del>
<ins class="diff-chg">dependencies
in
resolving
term
definitions.
By
continuing
</ins><a href="#object-context"><ins class="diff-chg">
Step
3.2
</ins>
</a>
<ins class="diff-new">until
no
changes
are
made,
mappings
to
IRIs
created
using
an
undefined
term
prefix
will
eventually
resolve
to
absolute
IRIs.
</ins></p><p class="issue">
<del class="diff-old">    {
    &quot;@base&quot;: ,
    &quot;@coerce&quot;: {
      &quot;@iri&quot;: &quot;@type&quot;
    }
}
</del>
<a href="https://github.com/json-ld/json-ld.org/issues/43">
<ins class="diff-chg">Issue
43
</ins>
</a>
<ins class="diff-chg">concerns
performing
</ins><abbr title="Internationalized Resource Identifier"><ins class="diff-chg">
IRI
</ins></abbr><ins class="diff-chg">
expansion
in
the
key
position
of
a
context
definition.
</ins></p>
</div>
<div id="iri-expansion" class="section">
<h3>
<span class="secno">
<ins class="diff-chg">3.4
</ins></span>
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
Expansion
</h3>
<p>
Keys
and
some
values
are
evaluated
to
produce
an
<del class="diff-old">IRI.
</del>
<abbr title="Internationalized Resource Identifier">
<ins class="diff-chg">IRI
</ins></abbr>.
This
section
defines
an
algorithm
for
transforming
a
value
representing
an
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
into
an
actual
<del class="diff-old">IRI.
</del>
<abbr title="Internationalized Resource Identifier">
<ins class="diff-chg">IRI
</ins></abbr>.
</p>
<p>
IRIs
may
be
represented
as
an
absolute
<del class="diff-old">IRI,
</del>
<abbr title="Internationalized Resource Identifier">
<ins class="diff-chg">IRI
</ins></abbr>,
a
<a class="tref internalDFN" title="term" href="#dfn-term">
term
<del class="diff-old">,
</del>
</a>
<ins class="diff-chg">or
</ins>
a
<a class="tref internalDFN" title="prefix" href="#dfn-prefix">
prefix
</a>:suffix
<del class="diff-old">construct,
or
as
a
value
relative
to
@base
or
@vocab
.
</del>
<ins class="diff-chg">construct.
</ins>
</p>
<p>
The
algorithm
for
generating
an
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
is:
</p>
<ol class="algorithm">
<li>
Split
the
value
into
a
<em>
prefix
</em>
and
<em>
suffix
</em>
from
the
first
occurrence
of
':'.
</li>
<li>
If
the
prefix
is
a
'_'
(underscore),
the
<del class="diff-old">IRI
is
unchanged.
</del>
<ins class="diff-chg">value
represents
a
named
</ins><a class="tref internalDFN" title="blank_node" href="#dfn-blank_node"><ins class="diff-chg">
blank
node
</ins></a>.
</li>
<li>
If
the
<a class="tref internalDFN" title="active_context" href="#dfn-active_context">
active
context
</a>
contains
a
<a class="tref internalDFN" title="term" href="#dfn-term">
term
</a>
mapping
for
<em>
prefix
<del class="diff-old">,
</del>
</em>
<ins class="diff-chg">using
a
case-sensitive
comparison,
</ins>
generate
an
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
by
prepending
the
mapped
prefix
to
the
(possibly
empty)
suffix
using
textual
concatenation.
Note
that
an
empty
suffix
and
no
suffix
(meaning
the
value
contains
no
':'
string
at
all)
are
treated
equivalently.
</li>
<li>
<del class="diff-old">If
</del>
<ins class="diff-chg">Otherwise,
use
</ins>
the
<del class="diff-old">IRI
being
processed
is
for
a
property
(i.e.,
a
key's
value
in
a
JSON
object
,
or
a
</del>
value
<del class="diff-old">in
a
</del>
<ins class="diff-chg">directly
as
an
</ins><abbr title="Internationalized Resource Identifier"><ins class="diff-chg">
IRI
</ins></abbr>.</li></ol><p></p><p class="note"><ins class="diff-chg">
Previous
versions
of
this
specification
used
</ins>
<code>
<del class="diff-old">@coerce
</del>
<ins class="diff-chg">@base
</ins>
</code>
<del class="diff-old">mapping)
</del>
and
<del class="diff-old">the
active
context
has
a
</del>
<code>
@vocab
</code>
<del class="diff-old">mapping,
join
the
mapped
value
</del>
to
<del class="diff-old">the
suffix
using
textual
concatenation.
If
the
</del>
<ins class="diff-chg">define
</ins><abbr title="Internationalized Resource Identifier">
IRI
<del class="diff-old">being
processed
is
for
a
subject
or
object
(i.e.,
not
a
property)
and
the
active
context
has
a
@base
mapping,
join
the
mapped
value
</del>
</abbr>
<ins class="diff-chg">prefixes
used
</ins>
to
<ins class="diff-new">resolve
relative
IRIs.
It
was
determined
that
this
added
too
much
complexity,
but
</ins>
the
<del class="diff-old">suffix
using
the
method
described
</del>
<ins class="diff-chg">issue
can
be
re-examined
</ins>
in
<del class="diff-old">[
RFC3986
].
Otherwise,
use
</del>
the
<del class="diff-old">value
directly
as
an
IRI.
</del>
<ins class="diff-chg">future
based
on
community
input.
</ins>
</p>
</div>
<div id="iri-compaction" class="section">
<h3>
<span class="secno">
<ins class="diff-chg">3.5
</ins></span><abbr title="Internationalized Resource Identifier">
IRI
</abbr>
Compaction
</h3>
<p>
Some
keys
and
values
are
expressed
using
IRIs.
This
section
defines
an
algorithm
for
transforming
an
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
to
a
compact
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
using
the
<a class="tref internalDFN" title="term" href="#dfn-term">
term
</a>
s
specified
in
the
<a class="tref internalDFN" title="local_context" href="#dfn-local_context">
local
context
</a>.
</p>
<p>
The
algorithm
for
generating
a
compacted
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
is:
</p>
<ol class="algorithm">
<li>
Search
every
key-value
pair
in
the
<a class="tref internalDFN" title="active_context" href="#dfn-active_context">
active
context
</a>
for
a
<a class="tref internalDFN" title="term" href="#dfn-term">
term
</a>
that
is
a
complete
match
against
the
<del class="diff-old">IRI.
</del>
<abbr title="Internationalized Resource Identifier">
<ins class="diff-chg">IRI
</ins></abbr>.
If
a
complete
match
is
found,
the
resulting
compacted
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
is
the
<a class="tref internalDFN" title="term" href="#dfn-term">
term
</a>
associated
with
the
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
in
the
<a class="tref internalDFN" title="active_context" href="#dfn-active_context">
active
context
</a>.
</li>
<li>
If
a
complete
match
is
not
found,
search
for
a
partial
match
from
the
beginning
of
the
<del class="diff-old">IRI.
</del>
<abbr title="Internationalized Resource Identifier">
<ins class="diff-chg">IRI
</ins></abbr>.
For
all
matches
that
are
found,
the
resulting
compacted
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
is
the
<a class="tref internalDFN" title="term" href="#dfn-term">
term
</a>
associated
with
the
partially
matched
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
in
the
<a class="tref internalDFN" title="active_context" href="#dfn-active_context">
active
context
</a>
concatenated
with
a
colon
(:)
character
and
the
unmatched
part
of
the
string.
If
there
is
more
than
one
compacted
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
produced,
the
final
value
is
the
shortest
and
lexicographically
least
value
of
the
entire
set
of
compacted
IRIs.
</li>
</ol>
<p>
</p>
</div>
<div id="value-expansion" class="section">
<h3>
<span class="secno">
<ins class="diff-chg">3.6
</ins></span>
Value
Expansion
</h3>
<p>
Some
values
in
JSON-LD
can
be
expressed
in
a
compact
form.
These
values
are
required
to
be
expanded
at
times
when
processing
JSON-LD
documents.
</p>
<p>
The
algorithm
for
expanding
a
<em>
value
<del class="diff-old">is:
</del>
</em>
<ins class="diff-chg">takes
an
</ins><a class="tref internalDFN" title="active_property" href="#dfn-active_property"><ins class="diff-chg">
active
property
</ins>
</a>
<ins class="diff-chg">and
</ins><a class="tref internalDFN" title="active_context" href="#dfn-active_context"><ins class="diff-chg">
active
context
</ins></a>.<ins class="diff-chg">
It
is
implemented
as
follows:
</ins></p>
<ol class="algorithm">
<li>
If
<del class="diff-old">the
key
that
</del>
<em>
<ins class="diff-chg">value
</ins></em>
is
<del class="diff-old">associated
with
</del>
<a class="tref internalDFN" title="true" href="#dfn-true">
<ins class="diff-chg">true
</ins></a>,<a class="tref internalDFN" title="false" href="#dfn-false"><ins class="diff-chg">
false
</ins></a><ins class="diff-chg">
or
</ins><a class="tref internalDFN" title="number" href="#dfn-number"><ins class="diff-chg">
number
</ins></a>,<ins class="diff-chg">
expand
</ins>
the
value
<del class="diff-old">has
an
associated
coercion
entry
in
the
local
context
,
</del>
<ins class="diff-chg">by
adding
a
two
new
key-value
pairs.
The
first
key-value
pair
will
be
</ins><code><ins class="diff-chg">
@value
</ins></code><ins class="diff-chg">
and
</ins>
the
<del class="diff-old">resulting
expansion
is
an
object
populated
according
to
</del>
<ins class="diff-chg">string
representation
of
</ins><em><ins class="diff-chg">
value
</ins></em>.<ins class="diff-chg">
The
second
key-value
pair
will
be
</ins><code><ins class="diff-chg">
@type&gt;
</ins></code>,<ins class="diff-chg">
and
</ins>
the
<del class="diff-old">following
steps:
</del>
<ins class="diff-chg">expanded
version
of
</ins><code><ins class="diff-chg">
xsd:boolean
</ins></code>,<code><ins class="diff-chg">
xsd:integer
</ins></code>,<ins class="diff-chg">
or
</ins><code><ins class="diff-chg">
xsd:double
</ins></code>,<ins class="diff-chg">
depending
on
</ins><em><ins class="diff-chg">
value
</ins></em>.</li>
<li>
<del class="diff-old">If
</del>
<ins class="diff-chg">Otherwise,
if
</ins><a class="tref internalDFN" title="active_property" href="#dfn-active_property"><ins class="diff-chg">
active
property
</ins></a><ins class="diff-chg">
is
</ins>
the
<del class="diff-old">coercion
</del>
target
<del class="diff-old">is
</del>
<ins class="diff-chg">of
an
</ins>
<code>
<del class="diff-old">@iri
,
</del>
<ins class="diff-chg">@id
</ins></code><ins class="diff-chg">
coercion,
</ins>
expand
the
value
by
adding
a
new
key-value
pair
where
the
key
is
<code>
<del class="diff-old">@iri
</del>
<ins class="diff-chg">@id
</ins>
</code>
and
the
value
is
the
expanded
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
according
to
the
<a href="#iri-expansion">
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
Expansion
</a>
rules.
</li>
<li>
<del class="diff-old">If
</del>
<ins class="diff-chg">Otherwise,
if
</ins><a class="tref internalDFN" title="active_property" href="#dfn-active_property"><ins class="diff-chg">
active
property
</ins></a><ins class="diff-chg">
is
</ins>
the
<del class="diff-old">coercion
</del>
target
<del class="diff-old">is
a
</del>
<ins class="diff-chg">of
</ins>
typed
<del class="diff-old">literal,
</del>
<ins class="diff-chg">literal
coercion,
</ins>
expand
<del class="diff-old">the
</del>
<em>
value
</em>
by
adding
two
new
key-value
pairs.
The
first
key-value
pair
will
be
<code>
<del class="diff-old">@literal
</del>
<ins class="diff-chg">@value
</ins>
</code>
and
the
unexpanded
value.
The
second
key-value
pair
will
be
<code>
<del class="diff-old">@datatype
</del>
<ins class="diff-chg">@type
</ins>
</code>
and
the
associated
coercion
datatype
expanded
according
to
the
<a href="#iri-expansion">
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
Expansion
</a>
rules.
</li>
<li>
<ins class="diff-chg">Otherwise,
if
the
</ins><a class="tref internalDFN" title="active_context" href="#dfn-active_context"><ins class="diff-chg">
active
context
</ins></a><ins class="diff-chg">
has
a
</ins><code><ins class="diff-chg">
@language
</ins></code>,<ins class="diff-chg">
expand
</ins><em><ins class="diff-chg">
value
</ins></em><ins class="diff-chg">
by
adding
two
new
key-value
pairs.
The
first
key-value
pair
will
be
</ins><code><ins class="diff-chg">
@value
</ins></code><ins class="diff-chg">
and
the
unexpanded
value.
The
second
key-value
pair
will
be
</ins><code><ins class="diff-chg">
@language
</ins></code><ins class="diff-chg">
and
value
of
</ins><code><ins class="diff-chg">
@language
</ins></code><ins class="diff-chg">
from
the
</ins><a class="tref internalDFN" title="active_context" href="#dfn-active_context"><ins class="diff-chg">
active
context
</ins></a>.</li><li><ins class="diff-chg">
Otherwise,
</ins><em><ins class="diff-chg">
value
</ins></em><ins class="diff-chg">
is
already
expanded.
</ins>
</li>
</ol>
</div>
<div id="value-compaction" class="section">
<h3>
<span class="secno">
<del class="diff-old">3.4
</del>
<ins class="diff-chg">3.7
</ins>
</span>
Value
Compaction
</h3>
<p>
Some
values,
such
as
IRIs
and
typed
literals,
may
be
expressed
in
an
expanded
form
in
JSON-LD.
These
values
are
required
to
be
compacted
at
times
when
processing
JSON-LD
documents.
</p>
<p>
The
algorithm
for
compacting
<del class="diff-old">a
</del>
<ins class="diff-chg">an
expanded
</ins>
value
<del class="diff-old">is:
</del>
<em>
<ins class="diff-chg">value
</ins></em><ins class="diff-chg">
takes
an
</ins><a class="tref internalDFN" title="active_property" href="#dfn-active_property"><ins class="diff-chg">
active
property
</ins></a><ins class="diff-chg">
and
</ins><a class="tref internalDFN" title="active_context" href="#dfn-active_context"><ins class="diff-chg">
active
context
</ins></a>.<ins class="diff-chg">
It
is
implemented
as
follows:
</ins>
</p>
<ol class="algorithm">
<li>
If
the
<del class="diff-old">local
</del>
<ins class="diff-chg">value
may
be
expressed
as
</ins><a class="tref internalDFN" title="true" href="#dfn-true"><ins class="diff-chg">
true
</ins></a>,<a class="tref internalDFN" title="false" href="#dfn-false"><ins class="diff-chg">
false
</ins></a><ins class="diff-chg">
or
</ins><a class="tref internalDFN" title="number" href="#dfn-number"><ins class="diff-chg">
number
</ins></a>,<ins class="diff-chg">
the
value
is
the
native
representation
of
the
</ins><code><ins class="diff-chg">
@value
</ins></code><ins class="diff-chg">
value.
</ins></li><li><ins class="diff-chg">
Otherwise,
if
the
</ins><a class="tref internalDFN" title="active_context" href="#dfn-active_context"><ins class="diff-chg">
active
</ins>
context
</a>
contains
a
coercion
target
for
the
key
that
<del class="diff-old">is
associated
with
</del>
<ins class="diff-chg">matches
the
expression
of
</ins>
the
value,
compact
the
value
using
the
following
steps:
<ol class="algorithm">
<li>
If
the
coercion
target
is
an
<code>
<del class="diff-old">@iri
</del>
<ins class="diff-chg">@id
</ins>
</code>,
the
compacted
value
is
the
value
associated
with
the
<code>
<del class="diff-old">@iri
</del>
<ins class="diff-chg">@id
</ins>
</code>
key,
processed
according
to
the
<a href="#iri-compaction">
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
Compaction
</a>
steps.
</li>
<li>
If
the
coercion
target
is
a
typed
literal,
the
compacted
value
is
the
value
associated
with
the
<code>
<del class="diff-old">@literal
</del>
<ins class="diff-chg">@value
</ins></code><ins class="diff-chg">
key.
</ins></li></ol></li><li><ins class="diff-chg">
Otherwise,
if
</ins><em><ins class="diff-chg">
value
</ins></em><ins class="diff-chg">
contains
an
</ins><code><ins class="diff-chg">
@id
</ins></code><ins class="diff-chg">
key,
the
compacted
value
is
</ins><em><ins class="diff-chg">
value
</ins></em><ins class="diff-chg">
with
the
value
of
</ins><code><ins class="diff-chg">
@id
</ins></code><ins class="diff-chg">
processed
according
to
the
</ins><a href="#iri-compaction"><abbr title="Internationalized Resource Identifier"><ins class="diff-chg">
IRI
</ins></abbr><ins class="diff-chg">
Compaction
</ins></a><ins class="diff-chg">
steps.
</ins></li><li><ins class="diff-chg">
Otherwise,
if
the
</ins><a class="tref internalDFN" title="active_context" href="#dfn-active_context"><ins class="diff-chg">
active
context
</ins></a><ins class="diff-chg">
contains
a
</ins><code><ins class="diff-chg">
@language
</ins></code>,<ins class="diff-chg">
which
matches
the
</ins><code><ins class="diff-chg">
@language
</ins></code><ins class="diff-chg">
of
the
value,
or
the
value
has
only
a
</ins><code><ins class="diff-chg">
@value
</ins></code><ins class="diff-chg">
key,
the
compacted
value
is
the
value
associated
with
the
</ins><code><ins class="diff-chg">
@value
</ins>
</code>
key.
</li>
<li>
Otherwise,
<ins class="diff-new">if
the
value
contains
a
</ins><code><ins class="diff-new">
@type
</ins></code><ins class="diff-new">
key,
the
compacted
value
is
</ins><em><ins class="diff-new">
value
</ins></em><ins class="diff-new">
with
the
</ins><code><ins class="diff-new">
@type
</ins></code><ins class="diff-new">
value
processed
according
to
the
</ins><a href="#iri-compaction"><abbr title="Internationalized Resource Identifier"><ins class="diff-new">
IRI
</ins></abbr><ins class="diff-new">
Compaction
</ins></a><ins class="diff-new">
steps.
</ins></li><li><ins class="diff-new">
Otherwise,
</ins>
the
value
is
not
modified.
</li>
</ol>
</div>
<div id="expansion" class="section">
<h3>
<span class="secno">
<del class="diff-old">3.5
</del>
<ins class="diff-chg">3.8
</ins>
</span>
Expansion
</h3>
<p>
Expansion
is
the
process
of
taking
a
JSON-LD
document
and
applying
a
context
such
that
all
<del class="diff-old">IRI,
</del>
<abbr title="Internationalized Resource Identifier">
<ins class="diff-chg">IRI
</ins></abbr>,
datatypes,
and
literal
values
are
expanded
so
that
the
context
is
no
longer
necessary.
JSON-LD
document
expansion
is
typically
used
as
a
part
of
<a href="#framing">
Framing
</a>
or
<a href="#normalization">
Normalization
</a>.
</p>
<p>
For
example,
assume
the
following
JSON-LD
input
document:
</p>
<del class="diff-old">{
   &quot;@context&quot;:
   {
      &quot;name&quot;: &quot;http://xmlns.com/foaf/0.1/name&quot;,
      &quot;homepage&quot;: &quot;http://xmlns.com/foaf/0.1/homepage&quot;,
      &quot;@coerce&quot;:
      {
         &quot;@iri&quot;: &quot;homepage&quot;
      }
   },
   &quot;name&quot;: &quot;Manu Sporny&quot;,
   &quot;homepage&quot;: &quot;http://manu.sporny.org/&quot;
</del>
<pre class="example">{
<ins class="diff-chg">   "@context":
   {
      "name": "http://xmlns.com/foaf/0.1/name",
      "homepage": {
        "@id": "http://xmlns.com/foaf/0.1/homepage",
        "@type", "@id"
      }
   },
   "name": "Manu Sporny",
   "homepage": "http://manu.sporny.org/"
</ins>
}
</pre>
<p>
Running
the
JSON-LD
Expansion
algorithm
against
the
JSON-LD
input
document
provided
above
would
result
in
the
following
output:
</p>
<del class="diff-old">{
   &quot;http://xmlns.com/foaf/0.1/name&quot;: &quot;Manu Sporny&quot;,
   &quot;http://xmlns.com/foaf/0.1/homepage&quot;:
   {
      &quot;@iri&quot;: &quot;http://manu.sporny.org/&quot;
   }
</del>
<pre class="example">{
<ins class="diff-chg">   "http://xmlns.com/foaf/0.1/name": "Manu Sporny",
   "http://xmlns.com/foaf/0.1/homepage": {
      "@id": "http://manu.sporny.org/"
   }
</ins>
}
</pre>
<div id="expansion-algorithm" class="section">
<h4>
<span class="secno">
<del class="diff-old">3.5.1
</del>
<ins class="diff-chg">3.8.1
</ins>
</span>
Expansion
Algorithm
</h4>
<del class="diff-old">This
</del>
<p>
<ins class="diff-chg">The
</ins>
algorithm
<del class="diff-old">is
</del>
<ins class="diff-chg">takes
three
input
variables:
an
</ins><a class="tref internalDFN" title="active_context" href="#dfn-active_context"><ins class="diff-chg">
active
context
</ins></a>,<ins class="diff-chg">
an
</ins><a class="tref internalDFN" title="active_property" href="#dfn-active_property"><ins class="diff-chg">
active
property
</ins></a>,<ins class="diff-chg">
and
</ins>
a
<del class="diff-old">work
in
progress,
do
not
implement
it.
If
</del>
<em>
<ins class="diff-chg">value
</ins></em><ins class="diff-chg">
to
be
expanded.
To
begin,
</ins>
the
<del class="diff-old">top-level
item
in
</del>
<a class="tref internalDFN" title="active_context" href="#dfn-active_context">
<ins class="diff-chg">active
context
</ins></a><ins class="diff-chg">
is
set
to
the
</ins><a class="tref internalDFN" title="initial_context" href="#dfn-initial_context"><ins class="diff-chg">
initial
context
</ins></a>,<a class="tref internalDFN" title="active_property" href="#dfn-active_property"><ins class="diff-chg">
active
property
</ins></a><ins class="diff-chg">
is
set
to
nil,
and
</ins><em><ins class="diff-chg">
value
</ins></em><ins class="diff-chg">
is
set
to
</ins>
the
<a class="tref internalDFN" title="json-ld_input" href="#dfn-json-ld_input">
JSON-LD
input
</a>.
</p>
<ol class="algorithm">
<li>
<ins class="diff-chg">If
</ins><em><ins class="diff-chg">
value
</ins></em>
is
an
<a class="tref internalDFN" title="array" href="#dfn-array">
array
</a>,
process
each
item
in
<del class="diff-old">the
array
</del>
<em>
<ins class="diff-chg">value
</ins></em>
recursively
using
this
<del class="diff-old">algorithm.
If
the
top-level
item
in
</del>
<ins class="diff-chg">algorithm,
passing
copies
of
</ins>
the
<del class="diff-old">JSON-LD
input
</del>
<a class="tref internalDFN" title="active_context" href="#dfn-active_context">
<ins class="diff-chg">active
context
</ins>
</a>
<ins class="diff-new">and
</ins><a class="tref internalDFN" title="active_property" href="#dfn-active_property"><ins class="diff-new">
active
property
</ins></a>.</li><li><ins class="diff-new">
Otherwise,
if
</ins><em><ins class="diff-new">
value
</ins></em>
is
an
<del class="diff-old">object,
update
</del>
<ins class="diff-chg">object
</ins><ol class="algorithm"><li><ins class="diff-chg">
Update
</ins>
the
<del class="diff-old">local
</del>
<a class="tref internalDFN" title="active_context" href="#dfn-active_context">
<ins class="diff-chg">active
</ins>
context
</a>
according
to
the
steps
outlined
in
the
<a href="#context">
context
</a>
<del class="diff-old">section.
Process
</del>
<ins class="diff-chg">section
and
remove
it
from
the
expanded
result.
</ins></li><li><ins class="diff-chg">
For
</ins>
each
<del class="diff-old">key,
expanding
</del>
<ins class="diff-chg">key
and
value
in
</ins><em><ins class="diff-chg">
value
</ins></em>:<ol class="algorithm"><li><ins class="diff-chg">
If
</ins>
the
key
<ins class="diff-new">is
</ins><code><ins class="diff-new">
@id
</ins></code><ins class="diff-new">
or
</ins><code><ins class="diff-new">
@type
</ins></code><ins class="diff-new">
and
the
value
is
a
</ins><a class="tref internalDFN" title="string" href="#dfn-string"><ins class="diff-new">
string
</ins></a>,<ins class="diff-new">
expand
the
value
</ins>
according
to
<a href="#iri-expansion">
<abbr title="Internationalized Resource Identifier">
<ins class="diff-new">IRI
</ins></abbr><ins class="diff-new">
Expansion
</ins></a>.</li><li><ins class="diff-new">
Otherwise,
if
the
key
is
</ins><code><ins class="diff-new">
@value
</ins></code>,<ins class="diff-new">
the
value
</ins><em class="rfc2119" title="must"><ins class="diff-new">
must
</ins></em><ins class="diff-new">
be
a
</ins><a class="tref internalDFN" title="string" href="#dfn-string"><ins class="diff-new">
string
</ins></a><ins class="diff-new">
and
is
not
subject
to
further
expansion.
</ins></li><li><ins class="diff-new">
Otherwise,
if
</ins>
the
<ins class="diff-new">key
is
not
a
</ins><a class="tref internalDFN" title="keyword" href="#dfn-keyword"><ins class="diff-new">
keyword
</ins></a>,<ins class="diff-new">
expand
the
key
according
to
</ins>
<a href="#iri-expansion">
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
Expansion
</a>
<del class="diff-old">rules.
</del>
<ins class="diff-chg">rules
and
set
as
</ins><a class="tref internalDFN" title="active_property" href="#dfn-active_property"><ins class="diff-chg">
active
property
</ins></a>.
</li>
<li>
<del class="diff-old">Process
each
</del>
<ins class="diff-chg">If
the
value
is
an
</ins><a class="tref internalDFN" title="array" href="#dfn-array"><ins class="diff-chg">
array
</ins></a>,<ins class="diff-chg">
and
</ins><a class="tref internalDFN" title="active_property" href="#dfn-active_property"><ins class="diff-chg">
active
property
</ins></a><ins class="diff-chg">
is
subject
to
</ins><code><ins class="diff-chg">
@list
</ins></code><ins class="diff-chg">
expansion,
replace
the
</ins>
value
<del class="diff-old">associated
</del>
with
<del class="diff-old">each
key:
</del>
<ins class="diff-chg">a
new
key-value
key
where
the
key
is
</ins><code><ins class="diff-chg">
@list
</ins></code><ins class="diff-chg">
and
value
set
to
the
current
value.
</ins></li>
<li>
If
the
value
is
an
<a class="tref internalDFN" title="array" href="#dfn-array">
array
</a>,
process
each
item
in
the
<a class="tref internalDFN" title="array" href="#dfn-array">
array
</a>
recursively
using
this
<del class="diff-old">algorithm.
</del>
<ins class="diff-chg">algorithm,
passing
copies
of
the
</ins><a class="tref internalDFN" title="active_context" href="#dfn-active_context"><ins class="diff-chg">
active
context
</ins></a><ins class="diff-chg">
and
</ins><a class="tref internalDFN" title="active_property" href="#dfn-active_property"><ins class="diff-chg">
active
property
</ins></a>.
</li>
<li>
If
the
value
is
an
object,
process
the
object
recursively
using
this
<del class="diff-old">algorithm.
</del>
<ins class="diff-chg">algorithm,
passing
copies
of
the
</ins><a class="tref internalDFN" title="active_context" href="#dfn-active_context"><ins class="diff-chg">
active
context
</ins></a><ins class="diff-chg">
and
</ins><a class="tref internalDFN" title="active_property" href="#dfn-active_property"><ins class="diff-chg">
active
property
</ins></a>.
</li>
<li>
Otherwise,
<del class="diff-old">check
to
see
the
associated
key
has
an
associated
coercion
rule.
If
the
value
should
be
coerced,
</del>
expand
the
value
according
to
the
<a href="#value-expansion">
Value
Expansion
</a>
<del class="diff-old">rules.
If
the
value
does
not
need
to
be
coerced,
leave
the
value
as-is.
</del>
<ins class="diff-chg">rules,
passing
</ins><a class="tref internalDFN" title="active_property" href="#dfn-active_property"><ins class="diff-chg">
active
property
</ins></a>.
</li>
</ol>
</li>
<li>
Remove
the
context
from
the
object.
</li>
</ol>
</li>
<li>
<ins class="diff-new">Otherwise,
expand
</ins><em><ins class="diff-new">
value
</ins></em><ins class="diff-new">
according
to
the
</ins><a href="#value-expansion"><ins class="diff-new">
Value
Expansion
</ins></a><ins class="diff-new">
rules,
passing
</ins><a class="tref internalDFN" title="active_property" href="#dfn-active_property"><ins class="diff-new">
active
property
</ins></a>.</li>
</ol>
</div>
<del class="diff-old">What
are
the
implications
for
expanding
lists?
</del>
</div>
<div id="compaction" class="section">
<h3>
<span class="secno">
<del class="diff-old">3.6
</del>
<ins class="diff-chg">3.9
</ins>
</span>
Compaction
</h3>
<p>
Compaction
is
the
process
of
taking
a
JSON-LD
document
and
applying
a
context
such
that
the
most
compact
form
of
the
document
is
generated.
JSON
is
typically
expressed
in
a
very
compact,
key-value
format.
That
is,
full
IRIs
are
rarely
used
as
keys.
At
times,
a
JSON-LD
document
may
be
received
that
is
not
in
its
most
compact
form.
JSON-LD,
via
the
API,
provides
a
way
to
compact
a
JSON-LD
document.
</p>
<p>
For
example,
assume
the
following
JSON-LD
input
document:
</p>
<del class="diff-old">{
   &quot;http://xmlns.com/foaf/0.1/name&quot;: &quot;Manu Sporny&quot;,
   &quot;http://xmlns.com/foaf/0.1/homepage&quot;:
   {
      &quot;@iri&quot;: &quot;http://manu.sporny.org/&quot;
   }
</del>
<pre class="example">{
<ins class="diff-chg">  "http://xmlns.com/foaf/0.1/name": "Manu Sporny",
  "http://xmlns.com/foaf/0.1/homepage": {
    "@id": "http://manu.sporny.org/"
  }
</ins>
}
</pre>
<p>
Additionally,
assume
the
following
developer-supplied
JSON-LD
context:
</p>
<del class="diff-old">{
   &quot;name&quot;: &quot;http://xmlns.com/foaf/0.1/name&quot;,
   &quot;homepage&quot;: &quot;http://xmlns.com/foaf/0.1/homepage&quot;,
   &quot;@coerce&quot;:
   {
      &quot;@iri&quot;: &quot;homepage&quot;
   }
</del>
<pre class="example">{
<ins class="diff-chg">  "name": "http://xmlns.com/foaf/0.1/name",
  "homepage": {
    "@id": "http://xmlns.com/foaf/0.1/homepage",
    "@type": "@id"
  }
</ins>
}
</pre>
<p>
Running
the
JSON-LD
Compaction
algorithm
given
the
context
supplied
above
against
the
JSON-LD
input
document
provided
above
would
result
in
the
following
output:
</p>
<del class="diff-old">{
   &quot;@context&quot;:
   {
      &quot;name&quot;: &quot;http://xmlns.com/foaf/0.1/name&quot;,
      &quot;homepage&quot;: &quot;http://xmlns.com/foaf/0.1/homepage&quot;,
      &quot;@coerce&quot;:
      {
         &quot;@iri&quot;: &quot;homepage&quot;
      }
   },
   &quot;name&quot;: &quot;Manu Sporny&quot;,
   &quot;homepage&quot;: &quot;http://manu.sporny.org/&quot;
</del>
<pre class="example">{
<ins class="diff-chg">  "@context": {
    "name": "http://xmlns.com/foaf/0.1/name",
    "homepage": {
      "@id": "http://xmlns.com/foaf/0.1/homepage",
      "@type": "@id"
    }
  },
  "name": "Manu Sporny",
  "homepage": "http://manu.sporny.org/"
</ins>
}
</pre>
<p>
The
compaction
algorithm
also
enables
the
developer
to
map
any
expanded
format
into
an
application-specific
compacted
format.
While
the
context
provided
above
mapped
<code>
http://xmlns.com/foaf/0.1/name
</code>
to
<strong>
name
</strong>,
it
could
have
also
mapped
it
to
any
arbitrary
string
provided
by
the
developer.
</p>
<div id="compaction-algorithm" class="section">
<h4>
<span class="secno">
<del class="diff-old">3.6.1
</del>
<ins class="diff-chg">3.9.1
</ins>
</span>
Compaction
Algorithm
</h4>
<del class="diff-old">This
</del>
<p>
<ins class="diff-chg">The
</ins>
algorithm
<del class="diff-old">is
</del>
<ins class="diff-chg">takes
two
input
variables:
an
</ins><a class="tref internalDFN" title="active_property" href="#dfn-active_property"><ins class="diff-chg">
active
property
</ins></a>,<ins class="diff-chg">
and
</ins>
a
<del class="diff-old">work
in
progress,
do
not
implement
it.
Perform
</del>
<em>
<ins class="diff-chg">value
</ins></em><ins class="diff-chg">
to
be
expanded.
To
begin,
the
</ins><a class="tref internalDFN" title="active_property" href="#dfn-active_property"><ins class="diff-chg">
active
property
</ins></a><ins class="diff-chg">
is
set
to
nil,
and
</ins><em><ins class="diff-chg">
value
</ins></em><ins class="diff-chg">
is
set
to
the
result
of
performing
</ins>
the
<a href="#expansion-algorithm">
Expansion
Algorithm
</a>
on
the
<a class="tref internalDFN" title="json-ld_input" href="#dfn-json-ld_input">
JSON-LD
input
</a>.
This
removes
any
existing
context
to
allow
the
given
context
to
be
cleanly
applied.
<del class="diff-old">Set
the
</del>
<ins class="diff-chg">The
</ins>
<a class="tref internalDFN" title="active_context" href="#dfn-active_context">
active
context
</a>
to
the
given
context.
</p>
<ol class="algorithm">
<li>
If
<del class="diff-old">the
top-level
item
</del>
<em>
<ins class="diff-chg">value
</ins></em>
is
an
<a class="tref internalDFN" title="array" href="#dfn-array">
array
</a>,
process
each
item
in
<del class="diff-old">the
array
recursively,
starting
at
</del>
<em>
<ins class="diff-chg">value
</ins></em><ins class="diff-chg">
recursively
using
</ins>
this
<del class="diff-old">step.
</del>
<ins class="diff-chg">algorithm,
passing
a
copy
of
the
</ins><a class="tref internalDFN" title="active_property" href="#dfn-active_property"><ins class="diff-chg">
active
property
</ins></a>.
</li>
<li>
<del class="diff-old">If
the
top-level
item
</del>
<ins class="diff-chg">Otherwise,
if
</ins><em><ins class="diff-chg">
value
</ins></em>
is
an
object,
<del class="diff-old">compress
</del>
<ins class="diff-chg">for
</ins>
each
key
<del class="diff-old">using
the
steps
defined
</del>
<ins class="diff-chg">and
value
</ins>
in
<em>
<ins class="diff-new">value
</ins></em><ol class="algorithm"><li><ins class="diff-new">
If
the
key
is
</ins><code><ins class="diff-new">
@id
</ins></code><ins class="diff-new">
or
</ins><code><ins class="diff-new">
@type
</ins></code><ol class="algorithm"><li><ins class="diff-new">
If
the
value
of
the
key
is
a
</ins><a class="tref internalDFN" title="string" href="#dfn-string"><ins class="diff-new">
string
</ins></a>,<ins class="diff-new">
the
compacted
value
is
the
result
of
performing
</ins>
<a href="#iri-compaction">
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
Compaction
</a>
<ins class="diff-new">on
the
value.
</ins></li><li><ins class="diff-new">
Otherwise,
the
compacted
value
is
the
result
of
performing
this
algorithm
on
the
value
with
the
current
</ins><a class="tref internalDFN" title="active_property" href="#dfn-active_property"><ins class="diff-new">
active
property
</ins></a>.</li></ol></li><li><ins class="diff-new">
Otherwise:
</ins><ol class="algorithm"><li><ins class="diff-new">
If
the
key
is
not
a
</ins><a class="tref internalDFN" title="keyword" href="#dfn-keyword"><ins class="diff-new">
keyword
</ins></a>,<ins class="diff-new">
set
as
</ins><a class="tref internalDFN" title="active_property" href="#dfn-active_property"><ins class="diff-new">
active
property
</ins></a>
and
<del class="diff-old">compress
each
</del>
<ins class="diff-chg">compact
according
to
</ins><a href="#iri-compaction"><abbr title="Internationalized Resource Identifier"><ins class="diff-chg">
IRI
</ins></abbr><ins class="diff-chg">
Compaction
</ins></a>.</li><li><ins class="diff-chg">
If
the
</ins>
value
<del class="diff-old">using
</del>
<ins class="diff-chg">is
an
object
</ins><ol class="algorithm"><li><ins class="diff-chg">
If
</ins>
the
<del class="diff-old">steps
defined
in
</del>
<ins class="diff-chg">value
contains
only
an
</ins><code><ins class="diff-chg">
@id
</ins></code><ins class="diff-chg">
key
or
the
value
contains
a
</ins><code><ins class="diff-chg">
@value
</ins></code><ins class="diff-chg">
key,
the
compacted
value
is
the
result
of
performing
</ins>
<a href="#value-compaction">
Value
Compaction
<del class="diff-old">.
</del>
</a>
<ins class="diff-chg">on
the
value.
</ins></li><li><ins class="diff-chg">
Otherwise,
if
the
value
contains
only
a
</ins><code><ins class="diff-chg">
@list
</ins></code><ins class="diff-chg">
key,
and
the
</ins><a class="tref internalDFN" title="active_property" href="#dfn-active_property"><ins class="diff-chg">
active
property
</ins></a><ins class="diff-chg">
is
subject
to
list
coercion,
the
compacted
value
is
the
result
of
performing
this
algorithm
on
that
value.
</ins></li><li><ins class="diff-chg">
Otherwise,
the
compacted
value
is
the
result
of
performing
this
algorithm
on
the
value.
</ins>
</li>
</ol>
<del class="diff-old">What
are
</del>
</li>
<li>
<ins class="diff-chg">Otherwise,
if
</ins>
the
<del class="diff-old">implications
for
compacting
lists?
</del>
<ins class="diff-chg">value
is
an
</ins><a class="tref internalDFN" title="array" href="#dfn-array"><ins class="diff-chg">
array
</ins></a>,<ins class="diff-chg">
the
compacted
value
is
the
result
of
performing
this
algorithm
on
the
value.
</ins></li><li><ins class="diff-chg">
Otherwise,
the
value
is
already
compacted.
</ins></li></ol></li></ol></li><li><ins class="diff-chg">
Otherwise,
the
compacted
value
is
the
</ins><em><ins class="diff-chg">
value
</ins></em>.</li></ol></div>
</div>
<div id="framing" class="section">
<h3>
<span class="secno">
<del class="diff-old">3.7
</del>
<ins class="diff-chg">3.10
</ins>
</span>
Framing
</h3>
<p>
JSON-LD
Framing
allows
developers
to
query
by
example
and
force
a
specific
tree
layout
to
a
JSON-LD
document.
</p>
<p>
A
JSON-LD
document
is
a
representation
of
a
directed
graph.
A
single
directed
graph
can
have
many
different
serializations,
each
expressing
exactly
the
same
information.
Developers
typically
work
with
trees,
represented
as
<a class="tref internalDFN" title="json_object" href="#dfn-json_object">
JSON
object
</a>
s.
While
mapping
a
graph
to
a
tree
can
be
done,
the
layout
of
the
end
result
must
be
specified
in
advance.
A
<dfn title="frame" id="dfn-frame">
Frame
</dfn>
can
be
used
by
a
developer
on
a
JSON-LD
document
to
specify
a
deterministic
layout
for
a
graph.
</p>
<p>
Framing
is
the
process
of
taking
a
JSON-LD
document,
which
expresses
a
graph
of
information,
and
applying
a
specific
graph
layout
(called
a
<a class="tref internalDFN" title="frame" href="#dfn-frame">
Frame
</a>
).
</p>
<p>
The
JSON-LD
document
below
expresses
a
library,
a
book
and
a
chapter:
</p>
<del class="diff-old">{
  &quot;@context&quot;: {
    &quot;Book&quot;:         &quot;http://example.org/vocab#Book&quot;,
    &quot;Chapter&quot;:      &quot;http://example.org/vocab#Chapter&quot;,
    &quot;contains&quot;:     &quot;http://example.org/vocab#contains&quot;,
    &quot;creator&quot;:      &quot;http://purl.org/dc/terms/creator&quot;
    &quot;description&quot;:  &quot;http://purl.org/dc/terms/description&quot;
    &quot;Library&quot;:      &quot;http://example.org/vocab#Library&quot;,
    &quot;title&quot;:        &quot;http://purl.org/dc/terms/title&quot;,
    &quot;@coerce&quot;:
    {
      &quot;@iri&quot;: &quot;contains&quot;
    },
  },
  &quot;@subject&quot;:
  [{
    &quot;@subject&quot;: &quot;http://example.com/library&quot;,
    &quot;@type&quot;: &quot;Library&quot;,
    &quot;contains&quot;: &quot;http://example.org/library/the-republic&quot;
  },
  {
    &quot;@subject&quot;: &quot;http://example.org/library/the-republic&quot;,
    &quot;@type&quot;: &quot;Book&quot;,
    &quot;creator&quot;: &quot;Plato&quot;,
    &quot;title&quot;: &quot;The Republic&quot;,
    &quot;contains&quot;: &quot;http://example.org/library/the-republic#introduction&quot;
  },
  {
    &quot;@subject&quot;: &quot;http://example.org/library/the-republic#introduction&quot;,
    &quot;@type&quot;: &quot;Chapter&quot;,
    &quot;description&quot;: &quot;An introductory chapter on The Republic.&quot;,
    &quot;title&quot;: &quot;The Introduction&quot;
  }]
</del>
<pre class="example">{
<ins class="diff-chg">  "@context": {
    "Book":         "http://example.org/vocab#Book",
    "Chapter":      "http://example.org/vocab#Chapter",
    "contains":     {
      "@id": "http://example.org/vocab#contains",
      "@type": "@id"
    },
    "creator":      "http://purl.org/dc/terms/creator",
    "description":  "http://purl.org/dc/terms/description",
    "Library":      "http://example.org/vocab#Library",
    "title":        "http://purl.org/dc/terms/title"
  },
  "@id":
  [{
    "@id": "http://example.com/library",
    "@type": "Library",
    "contains": "http://example.org/library/the-republic"
  },
  {
    "@id": "http://example.org/library/the-republic",
    "@type": "Book",
    "creator": "Plato",
    "title": "The Republic",
    "contains": "http://example.org/library/the-republic#introduction"
  },
  {
    "@id": "http://example.org/library/the-republic#introduction",
    "@type": "Chapter",
    "description": "An introductory chapter on The Republic.",
    "title": "The Introduction"
  }]
</ins>
}
</pre>
<p>
Developers
typically
like
to
operate
on
items
in
a
hierarchical,
tree-based
fashion.
Ideally,
a
developer
would
want
the
data
above
sorted
into
top-level
libraries,
then
the
books
that
are
contained
in
each
library,
and
then
the
chapters
contained
in
each
book.
To
achieve
that
layout,
the
developer
can
define
the
following
<a class="tref internalDFN" title="frame" href="#dfn-frame">
frame
</a>:
</p>
<del class="diff-old">{
  &quot;@context&quot;: {
    &quot;Book&quot;:         &quot;http://example.org/vocab#Book&quot;,
    &quot;Chapter&quot;:      &quot;http://example.org/vocab#Chapter&quot;,
    &quot;contains&quot;:     &quot;http://example.org/vocab#contains&quot;,
    &quot;creator&quot;:      &quot;http://purl.org/dc/terms/creator&quot;
    &quot;description&quot;:  &quot;http://purl.org/dc/terms/description&quot;
    &quot;Library&quot;:      &quot;http://example.org/vocab#Library&quot;,
    &quot;title&quot;:        &quot;http://purl.org/dc/terms/title&quot;
  },
  &quot;@type&quot;: &quot;Library&quot;,
  &quot;contains&quot;: {
    &quot;@type&quot;: &quot;Book&quot;,
    &quot;contains&quot;: {
      &quot;@type&quot;: &quot;Chapter&quot;
    }
  }
</del>
<pre class="example">{
<ins class="diff-chg">  "@context": {
    "Book":         "http://example.org/vocab#Book",
    "Chapter":      "http://example.org/vocab#Chapter",
    "contains":     "http://example.org/vocab#contains",
    "creator":      "http://purl.org/dc/terms/creator"
    "description":  "http://purl.org/dc/terms/description"
    "Library":      "http://example.org/vocab#Library",
    "title":        "http://purl.org/dc/terms/title"
  },
  "@type": "Library",
  "contains": {
    "@type": "Book",
    "contains": {
      "@type": "Chapter"
    }
  }
</ins>
}
</pre>
<p>
When
the
framing
algorithm
is
run
against
the
previously
defined
JSON-LD
document,
paired
with
the
<a class="tref internalDFN" title="frame" href="#dfn-frame">
frame
</a>
above,
the
following
JSON-LD
document
is
the
end
result:
</p>
<del class="diff-old">{
  &quot;@context&quot;: {
    &quot;Book&quot;:         &quot;http://example.org/vocab#Book&quot;,
    &quot;Chapter&quot;:      &quot;http://example.org/vocab#Chapter&quot;,
    &quot;contains&quot;:     &quot;http://example.org/vocab#contains&quot;,
    &quot;creator&quot;:      &quot;http://purl.org/dc/terms/creator&quot;
    &quot;description&quot;:  &quot;http://purl.org/dc/terms/description&quot;
    &quot;Library&quot;:      &quot;http://example.org/vocab#Library&quot;,
    &quot;title&quot;:        &quot;http://purl.org/dc/terms/title&quot;
  },
  &quot;@subject&quot;: &quot;http://example.org/library&quot;,
  &quot;@type&quot;: &quot;Library&quot;,
  &quot;contains&quot;: {
    
    &quot;@type&quot;: &quot;Book&quot;,
    
    
    &quot;contains&quot;: {
      
      &quot;@type&quot;: &quot;Chapter&quot;,
      
      
    },
  },
</del>
<pre class="example">{
<ins class="diff-chg">  "@context": {
    "Book":         "http://example.org/vocab#Book",
    "Chapter":      "http://example.org/vocab#Chapter",
    "contains":     "http://example.org/vocab#contains",
    "creator":      "http://purl.org/dc/terms/creator"
    "description":  "http://purl.org/dc/terms/description"
    "Library":      "http://example.org/vocab#Library",
    "title":        "http://purl.org/dc/terms/title"
  },
  "@id": "http://example.org/library",
  "@type": "Library",
  "contains": {
</ins>    <span class="diff">"@id": "http://example.org/library/the-republic",</span>
<ins class="diff-chg">
    "@type": "Book",
</ins>    <span class="diff">"creator": "Plato",</span>
    <span class="diff">"title": "The Republic",</span>
<ins class="diff-chg">
    "contains": {
</ins>      <span class="diff">"@id": "http://example.org/library/the-republic#introduction",</span>
<ins class="diff-chg">
      "@type": "Chapter",
</ins>      <span class="diff">"description": "An introductory chapter on The Republic.",</span>
      <span class="diff">"title": "The Introduction"</span>
<ins class="diff-chg">
    },
  },
</ins>
}
</pre>
<div id="framing-algorithm-terms" class="section">
<h4>
<span class="secno">
<del class="diff-old">3.7.1
</del>
<ins class="diff-chg">3.10.1
</ins>
</span>
Framing
Algorithm
Terms
</h4>
<p class="issue">
This
algorithm
is
a
work
in
progress,
do
not
implement
it.
<ins class="diff-new">There
was
also
a
recent
update
to
the
algorithm
in
order
to
auto-embed
frame-unspecified
data
(if
the
explicit
inclusion
flag
is
not
set)
in
order
to
preserve
graph
information.
This
change
is
particularly
important
for
comparing
subgraphs
(or
verifying
digital
signatures
on
subgraphs).
This
change
is
not
yet
reflected
in
the
algorithm
below.
</ins>
</p>
<dl>
<dt>
<dfn title="input_frame" id="dfn-input_frame">
input
frame
</dfn>
</dt>
<dd>
the
initial
<a class="tref internalDFN" title="frame" href="#dfn-frame">
frame
</a>
provided
to
the
framing
algorithm.
</dd>
<dt>
<dfn title="framing_context" id="dfn-framing_context">
framing
context
</dfn>
</dt>
<dd>
a
context
containing
the
<a class="tref internalDFN" title="object_embed_flag" href="#dfn-object_embed_flag">
object
embed
flag
</a>,
the
<a class="tref internalDFN" title="explicit_inclusion_flag" href="#dfn-explicit_inclusion_flag">
explicit
inclusion
flag
</a>
and
the
<a class="tref internalDFN" title="omit_default_flag" href="#dfn-omit_default_flag">
omit
default
flag
</a>.
</dd>
<dt>
<dfn title="object_embed_flag" id="dfn-object_embed_flag">
object
embed
flag
</dfn>
</dt>
<dd>
a
flag
specifying
that
objects
should
be
directly
embedded
in
the
output,
instead
of
being
referred
to
by
their
<del class="diff-old">IRI.
</del>
<abbr title="Internationalized Resource Identifier">
<ins class="diff-chg">IRI
</ins></abbr>.
</dd>
<dt>
<dfn title="explicit_inclusion_flag" id="dfn-explicit_inclusion_flag">
explicit
inclusion
flag
</dfn>
</dt>
<dd>
a
flag
specifying
that
for
properties
to
be
included
in
the
output,
they
must
be
explicitly
declared
in
the
<a class="tref internalDFN" title="framing_context" href="#dfn-framing_context">
framing
context
</a>.
</dd>
<dt>
<dfn title="omit_missing_properties_flag" id="dfn-omit_missing_properties_flag">
omit
missing
properties
flag
</dfn>
</dt>
<dd>
a
flag
specifying
that
properties
that
are
missing
from
the
<a class="tref internalDFN" title="json-ld_input" href="#dfn-json-ld_input">
JSON-LD
input
</a>
should
be
omitted
from
the
output.
</dd>
<dt>
<dfn title="omit_default_flag" id="dfn-omit_default_flag">
omit
default
flag
</dfn>
</dt>
<dd class="issue">
Referenced
from
<a class="tref internalDFN" title="framing_context" href="#dfn-framing_context">
framing
context
</a>,
but
not
defined
</dd>
<dt>
<dfn title="match_limit" id="dfn-match_limit">
match
limit
</dfn>
</dt>
<dd>
A
value
specifying
the
maximum
number
of
matches
to
accept
when
building
arrays
of
values
during
the
framing
algorithm.
A
value
of
-1
specifies
that
there
is
no
match
limit.
</dd>
<dt>
<dfn title="map_of_embedded_subjects" id="dfn-map_of_embedded_subjects">
map
of
embedded
subjects
</dfn>
</dt>
<dd>
A
map
that
tracks
if
a
subject
has
been
embedded
in
the
output
of
the
<a href="#framing-algorithm">
Framing
Algorithm
</a>.
</dd>
</dl>
</div>
<div id="framing-algorithm" class="section">
<h4>
<span class="secno">
<del class="diff-old">3.7.2
</del>
<ins class="diff-chg">3.10.2
</ins>
</span>
Framing
Algorithm
</h4>
<p>
The
framing
algorithm
takes
<a class="tref internalDFN" title="json-ld_input" href="#dfn-json-ld_input">
JSON-LD
input
</a>
that
has
been
normalized
according
to
the
<a href="#normalization-algorithm">
Normalization
Algorithm
</a>
(
<strong>
normalized
input
</strong>
),
an
<a class="tref internalDFN" title="input_frame" href="#dfn-input_frame">
input
frame
</a>
that
has
been
expanded
according
to
the
<a href="#expansion-algorithm">
Expansion
Algorithm
</a>
(
<strong>
expanded
frame
</strong>
),
and
a
number
of
options
and
produces
<a class="tref internalDFN" title="json-ld_output" href="#dfn-json-ld_output">
JSON-LD
output
</a>.
The
following
series
of
steps
is
the
recursive
portion
of
the
framing
algorithm:
</p>
<ol class="algorithm">
<li>
Initialize
the
<a class="tref internalDFN" title="framing_context" href="#dfn-framing_context">
framing
context
</a>
by
setting
the
<a class="tref internalDFN" title="object_embed_flag" href="#dfn-object_embed_flag">
object
embed
flag
</a>,
clearing
the
<a class="tref internalDFN" title="explicit_inclusion_flag" href="#dfn-explicit_inclusion_flag">
explicit
inclusion
flag
</a>,
and
clearing
the
<a class="tref internalDFN" title="omit_missing_properties_flag" href="#dfn-omit_missing_properties_flag">
omit
missing
properties
flag
</a>.
Override
these
values
based
on
input
options
provided
to
the
algorithm
by
the
application.
</li>
<li>
Generate
a
<dfn title="list_of_frames" id="dfn-list_of_frames">
list
of
frames
</dfn>
by
processing
the
<strong>
expanded
frame
</strong>:
<ol class="algorithm">
<li>
If
the
<strong>
expanded
frame
</strong>
is
not
an
<a class="tref internalDFN" title="array" href="#dfn-array">
array
</a>,
set
<a class="tref internalDFN" title="match_limit" href="#dfn-match_limit">
match
limit
</a>
to
1,
place
the
<strong>
expanded
frame
</strong>
into
the
<a class="tref internalDFN" title="list_of_frames" href="#dfn-list_of_frames">
list
of
frames
</a>,
and
set
the
<a class="tref internalDFN" title="json-ld_output" href="#dfn-json-ld_output">
JSON-LD
output
</a>
to
<code>
null
</code>.
</li>
<li>
If
the
<strong>
expanded
frame
</strong>
is
an
empty
<a class="tref internalDFN" title="array" href="#dfn-array">
array
</a>,
place
an
empty
object
into
the
<a class="tref internalDFN" title="list_of_frames" href="#dfn-list_of_frames">
list
of
frames
</a>,
set
the
<a class="tref internalDFN" title="json-ld_output" href="#dfn-json-ld_output">
JSON-LD
output
</a>
to
an
<a class="tref internalDFN" title="array" href="#dfn-array">
array
</a>,
and
set
<a class="tref internalDFN" title="match_limit" href="#dfn-match_limit">
match
limit
</a>
to
-1.
</li>
<li>
If
the
<strong>
expanded
frame
</strong>
is
a
non-empty
<a class="tref internalDFN" title="array" href="#dfn-array">
array
</a>,
add
each
item
in
the
<strong>
expanded
frame
</strong>
into
the
<a class="tref internalDFN" title="list_of_frames" href="#dfn-list_of_frames">
list
of
frames
</a>,
set
the
<a class="tref internalDFN" title="json-ld_output" href="#dfn-json-ld_output">
JSON-LD
output
</a>
to
an
<a class="tref internalDFN" title="array" href="#dfn-array">
array
</a>,
and
set
<a class="tref internalDFN" title="match_limit" href="#dfn-match_limit">
match
limit
</a>
to
-1.
</li>
</ol>
</li>
<li>
Create
a
<dfn title="match_array" id="dfn-match_array">
match
array
</dfn>
for
each
<strong>
expanded
frame
</strong>
in
the
<a class="tref internalDFN" title="list_of_frames" href="#dfn-list_of_frames">
list
of
frames
</a>
halting
when
either
the
<a class="tref internalDFN" title="match_limit" href="#dfn-match_limit">
match
limit
</a>
is
zero
or
the
end
of
the
<a class="tref internalDFN" title="list_of_frames" href="#dfn-list_of_frames">
list
of
frames
</a>
is
reached.
If
an
<strong>
expanded
frame
</strong>
is
not
an
object,
the
processor
<em class="rfc2119" title="must">
must
</em>
throw
a
<code>
Invalid
Frame
Format
</code>
exception.
Add
each
matching
item
from
the
<strong>
normalized
input
</strong>
to
the
<a class="tref internalDFN" title="matches_array" href="#dfn-matches_array">
matches
array
</a>
and
decrement
the
<a class="tref internalDFN" title="match_limit" href="#dfn-match_limit">
match
limit
</a>
by
1
if:
<ol class="algorithm">
<li>
The
<strong>
expanded
frame
</strong>
has
an
<code>
rdf:type
</code>
that
exists
in
the
item's
list
of
<code>
rdf:type
</code>
s.
Note:
the
<code>
rdf:type
</code>
can
be
an
<a class="tref internalDFN" title="array" href="#dfn-array">
array
</a>,
but
only
one
value
needs
to
be
in
common
between
the
item
and
the
<strong>
expanded
frame
</strong>
for
a
match.
</li>
<li>
The
<strong>
expanded
frame
</strong>
does
not
have
an
<code>
rdf:type
</code>
property,
but
every
property
in
the
<strong>
expanded
frame
</strong>
exists
in
the
item.
</li>
</ol>
<p class="issue">
<dfn title="matches_array" id="dfn-matches_array">
matches
array
</dfn>
not
defined
anywhere.
</p>
</li>
<li>
Process
each
item
in
the
<a class="tref internalDFN" title="match_array" href="#dfn-match_array">
match
array
</a>
with
its
associated
<dfn title="match_frame" id="dfn-match_frame">
match
frame
</dfn>:
<ol class="algorithm">
<li>
If
the
<a class="tref internalDFN" title="match_frame" href="#dfn-match_frame">
match
frame
</a>
contains
an
<code>
@embed
</code>
<del class="diff-old">keyword,
</del>
<a class="tref internalDFN" title="keyword" href="#dfn-keyword">
<ins class="diff-chg">keyword
</ins></a>,
set
the
<a class="tref internalDFN" title="object_embed_flag" href="#dfn-object_embed_flag">
object
embed
flag
</a>
to
its
value.
If
the
<a class="tref internalDFN" title="match_frame" href="#dfn-match_frame">
match
frame
</a>
contains
an
<code>
@explicit
</code>
<del class="diff-old">keyword,
</del>
<a class="tref internalDFN" title="keyword" href="#dfn-keyword">
<ins class="diff-chg">keyword
</ins></a>,
set
the
<a class="tref internalDFN" title="explicit_inclusion_flag" href="#dfn-explicit_inclusion_flag">
explicit
inclusion
flag
</a>
to
its
value.
Note:
if
the
<a class="tref internalDFN" title="keyword" href="#dfn-keyword">
keyword
</a>
exists,
but
the
value
is
neither
<code>
true
</code>
or
<code>
false
</code>,
set
the
associated
flag
to
<code>
true
</code>.
</li>
<li>
If
the
<a class="tref internalDFN" title="object_embed_flag" href="#dfn-object_embed_flag">
object
embed
flag
</a>
is
cleared
and
the
item
has
the
<code>
<del class="diff-old">@subject
</del>
<ins class="diff-chg">@id
</ins>
</code>
property,
replace
the
item
with
the
value
of
the
<code>
<del class="diff-old">@subject
</del>
<ins class="diff-chg">@id
</ins>
</code>
property.
</li>
<li>
If
the
<a class="tref internalDFN" title="object_embed_flag" href="#dfn-object_embed_flag">
object
embed
flag
</a>
is
set
and
the
item
has
the
<code>
<del class="diff-old">@subject
</del>
<ins class="diff-chg">@id
</ins>
</code>
property,
and
its
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
is
in
the
<a class="tref internalDFN" title="map_of_embedded_subjects" href="#dfn-map_of_embedded_subjects">
map
of
embedded
subjects
</a>,
throw
a
<code>
Duplicate
Embed
</code>
exception.
</li>
<li>
If
the
<a class="tref internalDFN" title="object_embed_flag" href="#dfn-object_embed_flag">
object
embed
flag
</a>
is
set
and
the
item
has
the
<code>
<del class="diff-old">@subject
</del>
<ins class="diff-chg">@id
</ins>
</code>
property
and
its
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
is
not
in
the
<a class="tref internalDFN" title="map_of_embedded_subjects" href="#dfn-map_of_embedded_subjects">
map
of
embedded
subjects
</a>:
<ol class="algorithm">
<li>
If
the
<a class="tref internalDFN" title="explicit_inclusion_flag" href="#dfn-explicit_inclusion_flag">
explicit
inclusion
flag
</a>
is
set,
then
delete
any
key
from
the
item
that
does
not
exist
in
the
<a class="tref internalDFN" title="match_frame" href="#dfn-match_frame">
match
frame
</a>,
except
<code>
<del class="diff-old">@subject
</del>
<ins class="diff-chg">@id
</ins>
</code>.
</li>
<li>
For
each
key
in
the
<a class="tref internalDFN" title="match_frame" href="#dfn-match_frame">
match
frame
</a>,
except
for
<del class="diff-old">keywords
</del>
<a class="tref internalDFN" title="keyword" href="#dfn-keyword">
<ins class="diff-chg">keyword
</ins></a><ins class="diff-chg">
s
</ins>
and
<code>
rdf:type
</code>:
<ol class="algorithm">
<li>
If
the
key
is
in
the
item,
then
build
a
new
<dfn title="recursion_input_list" id="dfn-recursion_input_list">
recursion
input
list
</dfn>
using
the
object
or
objects
associated
with
the
key.
If
any
object
contains
an
<code>
<del class="diff-old">@iri
</del>
<ins class="diff-chg">@id
</ins>
</code>
value
that
exists
in
the
<strong>
normalized
input
</strong>,
replace
the
object
in
the
<a class="tref internalDFN" title="recursion_input_list" href="#dfn-recursion_input_list">
recursion
input
list
</a>
with
a
new
object
containing
the
<code>
<del class="diff-old">@subject
</del>
<ins class="diff-chg">@id
</ins>
</code>
key
where
the
value
is
the
value
of
the
<code>
<del class="diff-old">@iri
</del>
<ins class="diff-chg">@id
</ins>
</code>,
and
all
of
the
other
key-value
pairs
for
that
subject.
Set
the
<dfn title="recursion_match_frame" id="dfn-recursion_match_frame">
recursion
match
frame
</dfn>
to
the
value
associated
with
the
<a class="tref internalDFN" title="match_frame" href="#dfn-match_frame">
match
frame
</a>
's
key.
Replace
the
value
associated
with
the
key
by
recursively
calling
this
algorithm
using
<a class="tref internalDFN" title="recursion_input_list" href="#dfn-recursion_input_list">
recursion
input
list
</a>,
<a class="tref internalDFN" title="recursion_match_frame" href="#dfn-recursion_match_frame">
recursion
match
frame
</a>
as
input.
</li>
<li>
If
the
key
is
not
in
the
item,
add
the
key
to
the
item
and
set
the
associated
value
to
an
empty
array
if
the
<a class="tref internalDFN" title="match_frame" href="#dfn-match_frame">
match
frame
</a>
key's
value
is
an
array
or
<code>
null
</code>
otherwise.
</li>
<li>
If
value
associated
with
the
item's
key
is
<code>
null
</code>,
process
the
<a class="tref internalDFN" title="omit_missing_properties_flag" href="#dfn-omit_missing_properties_flag">
omit
missing
properties
flag
</a>:
<ol class="algorithm">
<li>
If
the
value
associated
with
the
key
in
the
<a class="tref internalDFN" title="match_frame" href="#dfn-match_frame">
match
frame
</a>
is
an
array,
use
the
first
frame
from
the
array
as
the
<dfn title="property_frame" id="dfn-property_frame">
property
frame
</dfn>,
otherwise
set
the
<a class="tref internalDFN" title="property_frame" href="#dfn-property_frame">
property
frame
</a>
to
an
empty
object.
</li>
<li>
If
the
<a class="tref internalDFN" title="property_frame" href="#dfn-property_frame">
property
frame
</a>
contains
an
<code>
@omitDefault
</code>
<del class="diff-old">keyword,
</del>
<a class="tref internalDFN" title="keyword" href="#dfn-keyword">
<ins class="diff-chg">keyword
</ins></a>,
set
the
<a class="tref internalDFN" title="omit_missing_properties_flag" href="#dfn-omit_missing_properties_flag">
omit
missing
properties
flag
</a>
to
its
value.
Note:
if
the
<a class="tref internalDFN" title="keyword" href="#dfn-keyword">
keyword
</a>
exists,
but
the
value
is
neither
<code>
true
</code>
or
<code>
false
</code>,
set
the
associated
flag
to
<code>
true
</code>.
</li>
<li>
If
the
<a class="tref internalDFN" title="omit_missing_properties_flag" href="#dfn-omit_missing_properties_flag">
omit
missing
properties
flag
</a>
is
set,
delete
the
key
in
the
item.
Otherwise,
if
the
<code>
@default
</code>
<a class="tref internalDFN" title="keyword" href="#dfn-keyword">
keyword
</a>
is
set
in
the
<a class="tref internalDFN" title="property_frame" href="#dfn-property_frame">
property
frame
</a>
set
the
item's
value
to
the
value
of
<code>
@default
</code>.
</li>
</ol>
</li>
</ol>
</li>
</ol>
</li>
<li>
If
the
<a class="tref internalDFN" title="json-ld_output" href="#dfn-json-ld_output">
JSON-LD
output
</a>
is
<code>
null
</code>
set
it
to
the
item,
otherwise,
append
the
item
to
the
<a class="tref internalDFN" title="json-ld_output" href="#dfn-json-ld_output">
JSON-LD
output
</a>.
</li>
</ol>
</li>
<li>
Return
the
<a class="tref internalDFN" title="json-ld_output" href="#dfn-json-ld_output">
JSON-LD
output
</a>.
</li>
</ol>
<p>
The
final,
non-recursive
step
of
the
framing
algorithm
requires
the
<a class="tref internalDFN" title="json-ld_output" href="#dfn-json-ld_output">
JSON-LD
output
</a>
to
be
compacted
according
to
the
<a href="#compaction-algorithm">
Compaction
Algorithm
</a>
by
using
the
context
provided
in
the
<a class="tref internalDFN" title="input_frame" href="#dfn-input_frame">
input
frame
</a>.
The
resulting
value
is
the
final
output
of
the
compaction
algorithm
and
is
what
should
be
returned
to
the
application.
</p>
</div>
<p class="issue">
What
are
the
implications
for
framing
lists?
</p>
</div>
<div id="normalization" class="section">
<h3>
<span class="secno">
<del class="diff-old">3.8
</del>
<ins class="diff-chg">3.11
</ins>
</span>
Normalization
</h3>
<p class="issue">
This
algorithm
is
a
work
in
progress,
do
not
implement
it.
</p>
<p>
Normalization
is
the
process
of
taking
<a class="tref internalDFN" title="json-ld_input" href="#dfn-json-ld_input">
JSON-LD
input
</a>
and
performing
a
deterministic
transformation
on
that
input
that
results
in
<del class="diff-old">all
aspects
of
the
graph
being
fully
expanded
</del>
<ins class="diff-chg">a
normalized
</ins>
and
<del class="diff-old">named
in
the
</del>
<ins class="diff-chg">serialized
</ins>
JSON-LD
<del class="diff-old">output
.
The
normalized
output
</del>
<ins class="diff-chg">representation.
</ins></p><p><ins class="diff-chg">
Normalization
</ins>
is
<del class="diff-old">generated
</del>
<ins class="diff-chg">achieved
by
transforming
</ins><a class="tref internalDFN" title="json-ld_input" href="#dfn-json-ld_input"><ins class="diff-chg">
JSON-LD
input
</ins></a><ins class="diff-chg">
to
RDF,
as
described
</ins>
in
<del class="diff-old">such
a
way
that
any
conforming
</del>
<a href="#rdf-conversion">
<ins class="diff-chg">RDF
Conversion
</ins></a>,<ins class="diff-chg">
invoking
the
normalization
procedure
as
described
in
[
</ins><cite><a class="bibref" rel="biblioentry" href="#bib-RDF-NORMALIZATION"><ins class="diff-chg">
RDF-NORMALIZATION
</ins></a></cite><ins class="diff-chg">
],
returning
the
serialized
results.
</ins></p><div class="issue"><p><ins class="diff-chg">
There
an
open
issue
(
</ins><a href="https://github.com/json-ld/json-ld.org/issues/53"><ins class="diff-chg">
ISSUE-53
</ins></a><ins class="diff-chg">
)
on
the
purpose
and
results
of
performing
normalization.
Previous
versions
of
the
specification
generated
</ins>
JSON-LD
<del class="diff-old">processor
will
generate
identical
output
given
</del>
<ins class="diff-chg">as
</ins>
the
<del class="diff-old">same
input.
The
problem
</del>
<ins class="diff-chg">result
of
the
normalization
algorithm,
however
normalization
</ins>
is
a
<del class="diff-old">fairly
difficult
technical
problem
to
solve
because
it
requires
a
directed
graph
to
</del>
<ins class="diff-chg">process
required
across
different
linked
data
serializations.
To
</ins>
be
<del class="diff-old">ordered
into
a
set
of
nodes
and
edges
in
</del>
<ins class="diff-chg">useful,
</ins>
a
<del class="diff-old">deterministic
way.
This
</del>
<ins class="diff-chg">graph
requires
an
identical
normalized
representation
that
</ins>
is
<del class="diff-old">easy
to
do
when
all
</del>
<ins class="diff-chg">independent
</ins>
of
the
<del class="diff-old">nodes
have
unique
names,
but
very
difficult
to
do
when
some
</del>
<ins class="diff-chg">data
format
originally
used
for
markup,
or
the
way
in
which
language
features
or
publisher
preferences
create
differences
in
the
markup
</ins>
of
<ins class="diff-new">identical
graphs.
</ins></p><p><ins class="diff-new">
It
may
be
that
</ins>
the
<del class="diff-old">nodes
are
not
labeled.
</del>
<ins class="diff-chg">need
for
either
or
both
of
flattening
algorithm
or
to
retrieve
such
a
cryptographic
signature.
</ins>
</p>
</div>
<p>
Normalization
is
useful
when
comparing
two
graphs
against
one
another,
when
generating
a
detailed
list
of
differences
between
two
graphs,
and
when
generating
a
cryptographic
digital
signature
for
information
contained
in
a
graph
or
when
generating
a
hash
of
the
information
contained
in
a
graph.
</p>
<p>
The
example
below
is
an
un-normalized
JSON-LD
document:
</p>
<del class="diff-old">{
   &quot;@context&quot;:
   {
      &quot;name&quot;: &quot;http://xmlns.com/foaf/0.1/name&quot;,
      &quot;homepage&quot;: &quot;http://xmlns.com/foaf/0.1/homepage&quot;,
      &quot;xsd&quot;: &quot;http://www.w3.org/2001/XMLSchema#&quot;,
      &quot;@coerce&quot;:
      {
         &quot;@iri&quot;: [&quot;homepage&quot;]
      }
   },
   &quot;name&quot;: &quot;Manu Sporny&quot;,
   &quot;homepage&quot;: &quot;http://manu.sporny.org/&quot;
</del>
<pre class="example">{
<ins class="diff-chg">  "@context": {
    "name": "http://xmlns.com/foaf/0.1/name",
    "homepage": {
      "@id": "http://xmlns.com/foaf/0.1/homepage",
      "@type": "@id"
    },
    "xsd": "http://www.w3.org/2001/XMLSchema#"
  },
  "name": "Manu Sporny",
  "homepage": "http://manu.sporny.org/"
</ins>
}
</pre>
<p>
The
example
below
is
the
normalized
form
of
the
JSON-LD
document
above:
</p>
<p class="note">
Whitespace
is
used
below
to
aid
readability.
The
normalization
algorithm
for
JSON-LD
removes
all
unnecessary
whitespace
in
the
fully
normalized
form.
</p>
<del class="diff-old">[{
    &quot;@subject&quot;:
    {
        &quot;@iri&quot;: &quot;_:c14n0&quot;
    },
    &quot;http://xmlns.com/foaf/0.1/homepage&quot;:
    {
        &quot;@iri&quot;: &quot;http://manu.sporny.org/&quot;
    },
    &quot;http://xmlns.com/foaf/0.1/name&quot;: &quot;Manu Sporny&quot;
</del>
<p class="issue">
<ins class="diff-chg">Not
clear
that
whitespace
must
be
normalized,
as
the
JSON-LD
representation
can't
be
used
directly
to
create
a
signature,
but
would
be
based
on
the
serialized
result
of
[
</ins><cite><a class="bibref" rel="biblioentry" href="#bib-RDF-NORMALIZATION"><ins class="diff-chg">
RDF-NORMALIZATION
</ins></a></cite><ins class="diff-chg">
].
</ins></p><pre class="example">[{
<ins class="diff-chg">
  "@id": "_:c14n0",
  "http://xmlns.com/foaf/0.1/homepage": {
    "@id": "http://manu.sporny.org/"
  },
  "http://xmlns.com/foaf/0.1/name": "Manu Sporny"
</ins>
}]
</pre>
<p>
Notice
how
all
of
the
<a class="tref internalDFN" title="term" href="#dfn-term">
term
</a>
s
have
been
expanded
and
sorted
in
alphabetical
order.
Also,
notice
how
the
<a class="tref internalDFN" title="subject" href="#dfn-subject">
subject
</a>
has
been
labeled
with
a
<ins class="diff-chg">named
</ins><a class="tref internalDFN" title="blank_node" href="#dfn-blank_node">
blank
node
<del class="diff-old">identifier
.
</del>
</a>.
Normalization
ensures
that
any
arbitrary
graph
containing
exactly
the
same
information
would
be
normalized
to
exactly
the
same
form
shown
above.
</p>
<del class="diff-old">In
time,
there
may
be
more
than
one
normalization
algorithm
that
will
need
to
be
identified.
For
identification
purposes,
this
algorithm
is
named
&quot;Universal
Graph
Normalization
Algorithm
2011&quot;
(
UGNA2011
).
</del>
<div id="normalization-algorithm" class="section">
<h4>
<span class="secno">
<del class="diff-old">3.8.1
</del>
<ins class="diff-chg">3.11.1
</ins>
</span>
Normalization
Algorithm
<del class="diff-old">Terms
</del>
</h4>
<del class="diff-old">label
The
subject
IRI
associated
with
a
graph
node.
</del>
<p>
The
<del class="diff-old">subject
IRI
is
expressed
using
a
key-value
pair
in
a
JSON
object
where
the
key
is
@subject
and
the
value
is
a
string
that
is
an
IRI
or
a
JSON
object
containing
the
key
@iri
and
a
value
that
is
a
string
that
is
an
IRI.
list
of
expanded
nodes
A
list
of
all
nodes
in
</del>
<ins class="diff-chg">normalization
algorithm
transforms
</ins>
the
<a class="tref internalDFN" title="json-ld_input" href="#dfn-json-ld_input">
JSON-LD
input
</a>
<del class="diff-old">graph
containing
no
embedded
objects
and
having
all
keys
and
values
expanded
according
to
the
steps
in
the
Expansion
Algorithm
.
alpha
and
beta
values
The
words
alpha
and
beta
refer
to
the
first
and
second
nodes
or
values
being
examined
in
an
algorithm.
The
names
are
merely
used
to
refer
to
each
input
value
to
a
comparison
algorithm.
renaming
counter
A
counter
that
is
used
during
the
Node
Relabeling
Algorithm
.
The
counter
typically
starts
at
one
(1)
and
counts
up
for
every
node
that
is
relabeled.
There
will
be
two
such
renaming
counters
in
an
implementation
of
the
normalization
algorithm.
The
first
is
the
labeling
counter
and
the
second
is
the
deterministic
labeling
counter
.
serialization
label
An
identifier
that
is
created
to
aid
in
the
normalization
process
in
the
Deep
Comparison
Algorithm
.
The
value
typically
takes
the
form
of
s&lt;NUMBER&gt;
or
c&lt;NUMBER&gt;
.
3.8.2
Normalization
State
When
performing
the
steps
required
by
the
normalization
algorithm,
it
is
helpful
to
track
the
many
pieces
of
information
in
a
data
structure
called
the
normalization
state
.
Many
of
these
pieces
simply
provide
indexes
</del>
into
<del class="diff-old">the
graph.
The
information
contained
in
the
normalization
state
is
described
below.
node
state
Each
node
in
the
graph
will
be
assigned
a
node
state
.
This
state
contains
the
information
necessary
to
deterministically
label
all
nodes
in
the
graph.
A
node
state
includes:
node
reference
A
node
reference
is
a
reference
to
a
node
in
the
graph.
For
a
given
node
state
,
its
node
reference
refers
to
the
node
that
the
state
is
for.
When
a
node
state
is
created,
its
node
reference
should
be
to
the
node
it
is
created
for.
outgoing
list
Lists
the
label
s
for
all
nodes
that
are
properties
of
the
node
reference
.
This
list
should
be
initialized
by
iterating
over
every
object
associated
with
a
property
in
the
node
reference
adding
its
label
if
it
is
another
node.
incoming
list
Lists
the
label
s
for
all
nodes
in
the
graph
for
which
the
node
reference
is
a
property.
This
list
is
initialized
to
an
empty
list.
outgoing
serialization
map
Maps
node
label
s
to
serialization
label
s.
This
map
is
initialized
to
an
empty
map.
When
this
map
is
populated,
</del>
<ins class="diff-chg">RDF,
normalizes
</ins>
it
<del class="diff-old">will
be
filled
with
keys
that
are
the
label
s
of
every
node
in
the
graph
with
a
label
that
begins
with
_:
and
that
has
a
path,
via
properties,
that
starts
with
the
node
reference
.
outgoing
serialization
A
string
that
can
be
lexicographically
compared
to
the
outgoing
serialization
s
of
other
node
state
s.
It
is
a
representation
of
the
outgoing
serialization
map
and
other
related
information.
This
string
is
initialized
</del>
<ins class="diff-chg">according
</ins>
to
<del class="diff-old">an
empty
string.
incoming
serialization
map
</del>
<ins class="diff-chg">[
</ins><cite>
<del class="diff-old">Maps
node
label
s
to
serialization
label
s.
This
map
is
initialized
to
an
empty
map.
When
this
map
is
populated,
it
will
be
filled
with
keys
that
are
the
label
s
of
every
node
in
the
graph
with
a
label
</del>
<a class="bibref" rel="biblioentry" href="#bib-RDF-NORMALIZATION">
<ins class="diff-chg">RDF-NORMALIZATION
</ins>
</a>
<del class="diff-old">that
begins
with
_:
and
that
has
a
path,
via
properties,
that
ends
with
the
node
reference
.
</del>
<del class="diff-old">incoming
serialization
A
string
that
can
be
lexicographically
compared
to
the
outgoing
serialization
s
of
other
node
state
s.
It
is
a
representation
of
the
incoming
serialization
map
</del>
</cite>
<ins class="diff-chg">]
</ins>
and
<del class="diff-old">other
related
information.
This
string
is
initialized
to
an
empty
string.
node
state
map
A
mapping
from
a
node's
label
to
a
node
state
.
It
is
initialized
to
an
empty
map.
labeling
prefix
The
labeling
prefix
is
a
string
that
is
used
as
the
beginning
of
a
node
label
.
It
should
be
initialized
</del>
<ins class="diff-chg">then
transforms
back
</ins>
to
<del class="diff-old">a
random
base
string
that
starts
with
the
characters
_:
,
is
not
used
by
any
other
node's
label
in
the
JSON-LD
input
,
and
does
not
start
with
the
characters
_:c14n
.
</del>
<ins class="diff-chg">JSON-LD.
</ins>
The
<del class="diff-old">prefix
has
two
uses.
First
it
is
used
to
temporarily
name
nodes
during
the
normalization
algorithm
in
a
way
that
doesn't
collide
with
the
names
that
already
exist
as
well
as
the
names
that
will
be
generated
by
the
normalization
algorithm.
Second,
it
will
eventually
be
set
to
_:c14n
to
generate
the
final,
deterministic
labels
for
nodes
in
the
graph.
This
prefix
will
be
concatenated
with
the
labeling
counter
to
produce
a
node
label
.
For
example,
_:j8r3k
is
a
proper
initial
value
for
the
labeling
prefix
.
labeling
counter
A
counter
that
is
used
to
label
nodes.
It
is
appended
to
the
labeling
prefix
to
create
a
node
label
.
It
is
initialized
to
1
.
deterministic
labeling
counter
Not
defined.
map
of
flattened
nodes
A
map
containing
a
representation
of
all
nodes
in
the
graph
where
the
key
is
a
node
label
and
the
value
</del>
<ins class="diff-chg">result
</ins>
is
<del class="diff-old">a
single
JSON
</del>
<ins class="diff-chg">an
</ins>
object
<ins class="diff-chg">representation
</ins>
that
<del class="diff-old">has
no
nested
sub-objects
and
has
had
all
properties
for
the
same
node
merged
into
</del>
<ins class="diff-chg">deterministically
represents
</ins>
a
<del class="diff-old">single
JSON
object
.
3.8.3
Normalization
Algorithm
The
normalization
algorithm
expands
the
JSON-LD
input
,
flattens
the
data
structure,
and
creates
an
initial
set
of
names
for
all
nodes
in
the
</del>
<ins class="diff-chg">RDF
</ins>
graph.
<del class="diff-old">The
flattened
data
structure
is
then
processed
by
a
node
labeling
algorithm
in
order
to
get
a
fully
expanded
and
named
list
of
nodes
which
is
then
sorted.
The
result
is
a
deterministically
named
and
ordered
list
of
graph
nodes.
</del>
</p>
<ol class="algorithm">
<li>
<del class="diff-old">Expand
</del>
<ins class="diff-chg">Transform
</ins>
the
<a class="tref internalDFN" title="json-ld_input" href="#dfn-json-ld_input">
JSON-LD
input
</a>
<ins class="diff-new">to
RDF
</ins>
according
to
the
steps
in
the
<del class="diff-old">Expansion
</del>
<a href="#rdf-conversion-algorithm">
<ins class="diff-chg">RDF
Conversion
</ins>
Algorithm
<del class="diff-old">and
store
the
result
as
the
expanded
input
.
Create
a
normalization
state
</del>
</a>.
</li>
<li>
<del class="diff-old">Initialize
the
map
of
flattened
nodes
by
recursively
processing
every
expanded
node
in
the
expanded
input
in
depth-first
order:
If
the
expanded
node
is
an
unlabeled
node,
add
a
new
key-value
pair
to
the
expanded
node
where
the
key
is
@subject
and
the
value
is
the
concatenation
of
the
labeling
prefix
</del>
<ins class="diff-chg">Perform
[
</ins><cite><a class="bibref" rel="biblioentry" href="#bib-RDF-NORMALIZATION"><ins class="diff-chg">
RDF-NORMALIZATION
</ins>
</a>
<del class="diff-old">and
the
string
value
</del>
</cite>
<ins class="diff-chg">]
</ins>
of
<del class="diff-old">the
labeling
counter
.
Increment
the
labeling
counter
.
Add
the
expanded
node
</del>
<ins class="diff-chg">that
RDF
</ins>
to
<del class="diff-old">the
map
of
flattened
nodes
:
If
the
expanded
node
's
label
is
already
in
the
map
of
flattened
nodes
merge
all
properties
from
the
entry
in
the
map
</del>
<ins class="diff-chg">create
a
serialized
N-Triples
representation
</ins>
of
<del class="diff-old">flattened
nodes
into
</del>
the
<del class="diff-old">expanded
node
.
</del>
<ins class="diff-chg">RDF
graph.
</ins>
</li>
<li>
<del class="diff-old">Go
through
every
property
associated
with
an
</del>
<ins class="diff-chg">Construct
a
JSON
</ins><a class="tref internalDFN" title="array" href="#dfn-array">
array
<del class="diff-old">in
the
expanded
node
and
remove
any
duplicate
IRI
</del>
</a>
<del class="diff-old">entries
from
the
array.
If
the
resulting
array
only
has
one
IRI
entry,
change
it
from
an
</del>
<em>
array
</em>
to
<del class="diff-old">an
object.
Set
the
entry
for
the
expanded
node
's
label
in
the
map
of
flattened
nodes
to
the
expanded
node
.
After
exiting
the
recursive
step,
replace
the
reference
to
the
expanded
node
with
an
object
containing
a
single
key-value
pair
where
the
key
is
@iri
and
the
value
is
the
value
of
the
@subject
key
in
</del>
<ins class="diff-chg">serve
as
</ins>
the
<del class="diff-old">node.
</del>
<ins class="diff-chg">output
object.
</ins>
</li>
<li>
For
<del class="diff-old">every
entry
in
the
map
of
flattened
nodes
,
insert
a
key-value
pair
into
the
node
state
map
where
the
key
is
the
key
from
the
map
of
flattened
nodes
and
the
value
is
a
node
state
where
its
node
reference
refers
to
the
value
from
the
map
of
flattened
nodes
.
Populate
the
incoming
list
for
each
node
state
by
iterating
over
every
node
in
the
graph
and
adding
its
label
to
the
incoming
list
associated
with
</del>
each
<del class="diff-old">node
found
in
its
properties.
For
every
entry
in
the
node
state
map
that
has
a
label
that
begins
with
_:c14n
,
relabel
the
node
using
the
Node
Relabeling
Algorithm
.
Label
all
of
the
nodes
that
contain
a
@subject
key
associated
with
a
value
starting
with
_:
according
to
the
steps
in
the
Deterministic
Labeling
Algorithm
.
3.8.4
Node
Relabeling
Algorithm
This
algorithm
renames
a
node
by
generating
a
unique
new
label
and
updating
all
references
to
that
label
</del>
<ins class="diff-chg">triple
</ins>
in
the
<del class="diff-old">node
state
map
.
The
old
label
</del>
<ins class="diff-chg">N-Triples
document
having
</ins><em><ins class="diff-chg">
subject
</ins></em>,<em><ins class="diff-chg">
predicate
</ins></em>,
and
<del class="diff-old">the
normalization
state
must
be
given
as
an
input
to
the
algorithm.
The
old
label
is
the
current
label
of
the
node
that
is
to
be
relabeled.
The
node
relabeling
algorithm
is
as
follows:
</del>
<em>
<ins class="diff-chg">object
</ins></em>:
<ol class="algorithm">
<li>
If
<del class="diff-old">the
labeling
prefix
</del>
<em>
<ins class="diff-chg">predicate
</ins></em>
is
<code>
<del class="diff-old">_:c14n
and
the
old
label
begins
with
_:c14n
then
return
as
the
node
has
already
been
renamed.
Generate
the
new
label
by
concatenating
the
labeling
prefix
with
the
string
value
of
the
labeling
counter
.
Increment
the
labeling
counter
.
For
the
node
state
associated
with
the
old
label
,
update
every
node
</del>
<ins class="diff-chg">http://www.w3.org/1999/02/22-rdf-syntax-ns#first
</ins></code>,<ins class="diff-chg">
let
</ins><em><ins class="diff-chg">
object
representation
</ins></em><ins class="diff-chg">
be
</ins><em><ins class="diff-chg">
object
</ins></em><ins class="diff-chg">
represented
</ins>
in
<del class="diff-old">the
incoming
list
by
changing
all
the
properties
that
reference
the
old
label
to
the
new
label
.
Change
the
old
label
key
</del>
<ins class="diff-chg">expanded
form
as
described
</ins>
in
<del class="diff-old">the
node
state
map
to
the
new
label
and
set
the
associated
node
reference
's
label
to
the
new
label
</del>
<a href="#value-expansion">
<ins class="diff-chg">Value
Expansion
</ins>
</a>.
<del class="diff-old">3.8.5
Deterministic
Labeling
Algorithm
The
deterministic
labeling
algorithm
takes
the
normalization
state
and
produces
a
list
of
finished
nodes
that
is
sorted
and
contains
deterministically
named
and
expanded
nodes
from
the
graph.
</del>
<ol class="algorithm">
<li>
Set
<em>
<ins class="diff-new">value
</ins></em><ins class="diff-new">
as
</ins>
the
<del class="diff-old">labeling
prefix
to
_:c14n
,
the
labeling
counter
to
1
,
the
list
of
finished
nodes
to
an
empty
array,
and
create
an
empty
array,
the
list
of
unfinished
nodes
.
For
each
node
reference
in
the
node
state
map
:
If
the
node's
label
does
not
start
with
_:
then
put
the
node
reference
</del>
<ins class="diff-chg">last
entry
</ins>
in
<del class="diff-old">the
list
of
finished
nodes
.
</del>
<em>
<ins class="diff-chg">array
</ins></em>.
</li>
<li>
If
the
<del class="diff-old">node's
label
does
start
with
_:
then
put
the
node
reference
</del>
<ins class="diff-chg">last
entry
</ins>
in
<del class="diff-old">the
list
of
unfinished
nodes
.
Append
to
the
list
of
finished
nodes
by
processing
the
remainder
of
the
list
of
unfinished
nodes
until
it
</del>
<em>
<ins class="diff-chg">value
</ins></em>
is
<del class="diff-old">empty:
Sort
the
list
of
unfinished
nodes
in
descending
order
according
to
the
Deep
Comparison
Algorithm
to
determine
the
sort
order.
Create
a
list
of
labels
and
initialize
</del>
<em>
<ins class="diff-chg">subject
</ins></em>,<ins class="diff-chg">
replace
</ins>
it
<del class="diff-old">to
an
empty
array.
For
the
first
node
from
</del>
<ins class="diff-chg">with
</ins>
the
<del class="diff-old">list
of
unfinished
nodes
:
Add
its
label
</del>
<ins class="diff-chg">a
</ins><a class="tref internalDFN" title="json_object" href="#dfn-json_object"><ins class="diff-chg">
JSON
object
</ins>
</a>
<del class="diff-old">to
the
list
of
labels
.
For
each
key-value
pair
from
its
associated
outgoing
serialization
map
,
add
the
key
to
</del>
<ins class="diff-chg">having
</ins>
a
<del class="diff-old">list
and
then
sort
the
list
according
to
the
lexicographical
order
of
the
keys'
associated
values.
Append
the
list
to
the
list
of
nodes
to
label
.
list
of
nodes
to
label
not
defined.
For
each
key-value
</del>
<ins class="diff-chg">key/value
</ins>
pair
<del class="diff-old">from
its
associated
incoming
serialization
map
,
add
the
key
to
a
list
and
then
sort
the
list
according
to
the
lexicographical
order
of
the
keys'
associated
values.
Append
the
list
to
the
list
</del>
of
<del class="diff-old">nodes
to
label
.
For
each
label
in
the
list
of
labels
,
relabel
the
associated
node
according
to
the
Node
Relabeling
Algorithm
.
If
any
outgoing
serialization
map
contains
a
key
that
matches
the
label
,
clear
the
map
and
set
the
associated
outgoing
serialization
to
an
empty
string.
If
any
incoming
serialization
map
contains
a
key
that
matches
the
label
,
clear
the
map
and
set
the
associated
incoming
serialization
to
an
empty
string.
Remove
each
node
with
a
label
that
starts
with
</del>
<code>
<del class="diff-old">_:c14n
</del>
<ins class="diff-chg">@list
</ins>
</code>
<del class="diff-old">from
the
list
of
unfinished
nodes
and
add
it
to
the
list
of
finished
nodes
.
Sort
the
list
of
finished
nodes
in
descending
order
according
to
the
Deep
Comparison
Algorithm
to
determine
the
sort
order.
3.8.6
Shallow
Comparison
Algorithm
The
shallow
comparison
algorithm
takes
two
unlabeled
nodes,
alpha
and
beta
,
as
input
and
determines
which
one
should
come
first
in
a
sorted
list.
The
following
algorithm
determines
the
steps
that
are
executed
in
order
to
determine
the
node
that
should
come
first
in
a
list:
Compare
the
total
number
of
node
properties.
The
node
with
fewer
properties
is
first.
Lexicographically
sort
the
property
IRI
s
for
each
node
</del>
and
<del class="diff-old">compare
the
sorted
lists.
If
an
IRI
is
found
to
be
lexicographically
smaller,
the
node
containing
that
IRI
is
first.
Compare
the
values
of
each
property
against
one
another:
The
node
associated
with
fewer
property
values
is
first.
Create
</del>
an
<del class="diff-old">alpha
list
by
adding
all
values
associated
with
the
alpha
property
that
are
not
unlabeled
nodes.
Create
a
beta
list
by
adding
all
values
associated
with
the
beta
property
that
is
not
an
unlabeled
node.
Compare
the
length
of
alpha
list
</del>
<a class="tref internalDFN" title="array" href="#dfn-array">
<ins class="diff-chg">array
</ins>
</a>
<del class="diff-old">and
beta
list
.
The
node
associated
with
the
list
</del>
containing
<del class="diff-old">the
fewer
number
of
items
is
first.
</del>
<em>
<ins class="diff-chg">object
representation
</ins></em>.
</li>
<li>
<del class="diff-old">Sort
alpha
list
and
beta
list
according
to
the
Object
Comparison
Algorithm
.
For
each
offset
into
the
alpha
list
,
compare
the
item
at
the
offset
against
the
item
at
</del>
<ins class="diff-chg">Otherwise,
</ins>
the
<del class="diff-old">same
offset
</del>
<ins class="diff-chg">last
key/value
entry
</ins>
in
<del class="diff-old">the
beta
list
according
to
the
Object
Comparison
Algorithm
.
The
node
associated
with
the
lesser
item
is
first.
Process
the
incoming
list
s
associated
with
each
node
to
determine
order:
The
node
with
the
shortest
incoming
list
is
first.
Sort
the
incoming
list
s
according
to
incoming
property
and
then
incoming
label
.
The
node
associated
with
the
fewest
number
of
incoming
nodes
is
first.
For
each
offset
into
the
incoming
list
s,
compare
the
associated
properties
and
label
s:
The
node
associated
with
</del>
<em>
<ins class="diff-chg">value
</ins></em><em class="rfc2119" title="must"><ins class="diff-chg">
must
</ins></em><ins class="diff-chg">
be
</ins>
a
<del class="diff-old">label
that
does
not
begin
with
_:
is
first.
If
the
nodes'
label
s
do
not
begin
with
_:
,
then
the
node
associated
with
the
lexicographically
lesser
label
is
first.
The
node
associated
with
the
lexicographically
lesser
associated
property
is
first.
The
node
with
the
label
that
does
not
begin
with
_:c14n
is
first.
The
node
with
the
lexicographically
lesser
label
is
first.
Otherwise,
the
nodes
are
equivalent.
3.8.7
Object
Comparison
Algorithm
The
</del>
<a class="tref internalDFN" title="json_object" href="#dfn-json_object">
<ins class="diff-chg">JSON
</ins>
object
<del class="diff-old">comparison
algorithm
is
designed
to
compare
two
graph
node
property
values,
alpha
and
beta
,
against
the
other.
The
algorithm
is
useful
when
sorting
two
lists
of
graph
node
properties.
If
one
of
the
values
is
a
string
</del>
</a>
<del class="diff-old">and
the
other
is
not,
the
value
that
is
</del>
<ins class="diff-chg">having
</ins>
a
<del class="diff-old">string
is
first.
If
both
values
are
string
s,
the
lexicographically
lesser
string
is
first.
If
one
</del>
<ins class="diff-chg">single
key
</ins>
of
<del class="diff-old">the
values
is
</del>
<em>
<ins class="diff-chg">@list
</ins></em><ins class="diff-chg">
with
</ins>
a
<del class="diff-old">literal
and
the
other
is
not,
the
</del>
value
that
is
<del class="diff-old">a
literal
is
first.
If
both
values
are
literals:
The
lexicographically
lesser
string
associated
with
@literal
is
first.
The
lexicographically
lesser
string
associated
with
@datatype
is
first.
The
lexicographically
lesser
string
associated
with
@language
is
first.
</del>
<ins class="diff-chg">an
</ins><a class="tref internalDFN" title="array" href="#dfn-array"><ins class="diff-chg">
array
</ins></a>.<ins class="diff-chg">
Append
</ins><em><ins class="diff-chg">
object
representation
</ins></em>.
</li>
</ol>
</li>
<li>
<del class="diff-old">If
both
values
are
expanded
IRI
s,
the
lexicographically
lesser
string
associated
with
@iri
</del>
<ins class="diff-chg">Otherwise,
if
</ins><em><ins class="diff-chg">
predicate
</ins></em>
is
<del class="diff-old">first.
</del>
<code>
<ins class="diff-chg">http://www.w3.org/1999/02/22-rdf-syntax-ns#rest
</ins></code>,<ins class="diff-chg">
ignore
this
triple.
</ins>
</li>
<li>
Otherwise,
<del class="diff-old">the
two
values
are
equivalent.
3.8.8
Deep
Comparison
Algorithm
The
deep
comparison
algorithm
is
used
to
compare
the
difference
between
two
nodes,
alpha
and
beta
.
A
deep
comparison
takes
the
incoming
and
outgoing
node
edges
in
a
graph
into
account
if
the
number
of
properties
and
value
of
those
properties
are
identical.
The
algorithm
is
helpful
when
sorting
a
list
of
nodes
and
will
return
whichever
node
should
be
placed
first
in
a
list
</del>
if
the
<del class="diff-old">two
nodes
are
not
truly
equivalent.
When
performing
the
steps
required
by
the
deep
comparison
algorithm,
it
is
helpful
to
track
state
information
about
mappings.
The
information
contained
</del>
<ins class="diff-chg">last
entry
</ins>
in
<del class="diff-old">a
mapping
state
is
described
below.
mapping
state
mapping
counter
Keeps
track
of
the
number
of
nodes
that
have
been
mapped
to
serialization
label
s.
It
is
initialized
to
1
.
processed
labels
map
Keeps
track
of
the
label
s
of
nodes
that
have
already
been
assigned
serialization
label
s.
It
is
initialized
to
an
empty
map.
serialized
labels
map
Maps
a
node
label
to
its
associated
serialization
label
.
It
is
initialized
to
an
empty
map.
adjacent
info
map
Maps
a
serialization
label
to
the
node
label
associated
with
it,
the
list
of
sorted
serialization
label
s
for
adjacent
nodes,
and
the
map
of
adjacent
node
serialization
label
s
to
their
associated
node
label
s.
It
is
initialized
to
an
empty
map.
key
stack
A
stack
where
each
element
contains
an
array
of
adjacent
serialization
label
s
and
an
index
into
that
array.
It
is
initialized
to
a
stack
containing
a
single
element
where
its
</del>
<em>
array
<del class="diff-old">contains
a
single
string
element
s1
and
its
index
is
set
to
0
.
serialized
keys
Keeps
track
of
which
serialization
label
s
have
already
been
written
at
least
once
to
the
serialization
string
.
It
is
initialized
to
an
empty
map.
serialization
string
A
string
that
is
incrementally
updated
as
a
serialization
is
built.
It
is
initialized
to
an
empty
string.
The
deep
comparison
algorithm
</del>
</em>
is
<del class="diff-old">as
follows:
Perform
a
comparison
between
alpha
and
beta
according
to
the
Shallow
Comparison
Algorithm
.
If
the
result
does
</del>
not
<del class="diff-old">show
that
the
two
nodes
are
equivalent,
return
the
result.
Compare
incoming
and
outgoing
edges
for
each
node,
updating
their
associated
node
state
as
each
node
is
processed:
If
the
outgoing
serialization
map
for
alpha
is
empty,
generate
the
serialization
according
to
the
Node
Serialization
Algorithm
.
Provide
alpha
's
node
state
,
</del>
a
<del class="diff-old">new
mapping
state
,
outgoing
direction
to
the
algorithm
as
inputs.
If
the
outgoing
serialization
map
for
beta
is
empty,
generate
the
serialization
according
to
the
Node
Serialization
Algorithm
.
Provide
beta
</del>
<a class="tref internalDFN" title="json_object" href="#dfn-json_object">
<ins class="diff-chg">JSON
Object
</ins>
</a>
<del class="diff-old">'s
node
state
,
a
new
mapping
state
,
and
</del>
<ins class="diff-chg">with
an
</ins>
<code>
<del class="diff-old">outgoing
direction
</del>
<ins class="diff-chg">@id
</ins>
</code>
<del class="diff-old">to
the
algorithm
as
inputs.
If
alpha
's
outgoing
serialization
is
lexicographically
less
than
beta
's,
then
alpha
is
first.
If
it
is
greater,
then
beta
is
first.
If
the
incoming
serialization
map
for
alpha
is
empty,
generate
the
serialization
according
to
the
Node
Serialization
Algorithm
.
Provide
alpha
's
node
state
,
a
new
mapping
state
with
its
serialized
labels
map
set
to
</del>
<ins class="diff-chg">having
</ins>
a
<del class="diff-old">copy
</del>
<ins class="diff-chg">value
</ins>
of
<del class="diff-old">alpha
's
outgoing
serialization
map
,
and
incoming
direction
to
the
algorithm
as
inputs.
</del>
<em>
<ins class="diff-chg">subject
</ins></em>:<ol class="algorithm">
<li>
<del class="diff-old">If
the
incoming
serialization
map
for
beta
is
empty,
generate
the
serialization
according
to
the
Node
Serialization
Algorithm
.
Provide
beta
's
node
state
,
</del>
<ins class="diff-chg">Create
</ins>
a
new
<del class="diff-old">mapping
state
</del>
<a class="tref internalDFN" title="json_object" href="#dfn-json_object">
<ins class="diff-chg">JSON
Object
</ins>
</a>
with
<del class="diff-old">its
serialized
labels
map
set
to
a
copy
</del>
<ins class="diff-chg">key/value
pair
</ins>
of
<del class="diff-old">beta
's
outgoing
serialization
map
,
and
</del>
<code>
<del class="diff-old">incoming
direction
</del>
<ins class="diff-chg">@id
</ins>
</code>
<del class="diff-old">to
the
algorithm
as
inputs.
If
alpha
's
incoming
serialization
is
lexicographically
less
than
beta
's,
then
alpha
is
first.
If
it
is
greater,
then
beta
is
first.
3.8.9
Node
Serialization
Algorithm
The
node
serialization
algorithm
takes
a
node
state
,
a
mapping
state
,
</del>
and
a
<del class="diff-old">direction
(either
outgoing
direction
or
incoming
direction
)
as
inputs
</del>
<ins class="diff-chg">string
representation
of
</ins><em><ins class="diff-chg">
subject
</ins></em>
and
<del class="diff-old">generates
a
deterministic
serialization
for
the
node
reference
.
If
the
label
exists
in
the
processed
labels
map
,
terminate
the
algorithm
</del>
<ins class="diff-chg">use
</ins>
as
<del class="diff-old">the
serialization
label
has
already
been
created.
Set
the
</del>
<em>
value
<del class="diff-old">associated
with
the
label
in
the
processed
labels
map
to
true
.
</del>
</em>.
</li>
<li>
<del class="diff-old">Generate
the
next
serialization
label
for
the
label
according
</del>
<ins class="diff-chg">Otherwise,
set
</ins><em><ins class="diff-chg">
value
</ins></em>
to
<del class="diff-old">the
Serialization
Label
Generation
Algorithm
.
Create
an
empty
map
called
the
adjacent
serialized
labels
map
</del>
that
<del class="diff-old">will
store
mappings
from
serialization
label
s
to
adjacent
node
label
s.
</del>
<ins class="diff-chg">value.
</ins>
</li>
<del class="diff-old">Create
an
empty
array
called
the
adjacent
unserialized
labels
list
that
will
store
label
s
of
adjacent
nodes
that
haven't
been
assigned
serialization
label
s
yet.
</del>
</ol>
</li>
<li>
<del class="diff-old">For
every
label
in
a
list,
where
the
list
the
outgoing
list
if
the
direction
is
</del>
<ins class="diff-chg">If
</ins>
<code>
<del class="diff-old">outgoing
direction
</del>
<ins class="diff-chg">predicate
</ins>
</code>
<del class="diff-old">and
the
incoming
list
otherwise,
if
the
label
starts
with
_:
,
it
</del>
is
<del class="diff-old">the
target
node
label
:
</del>
<code>
<ins class="diff-chg">http://www.w3.org/1999/02/22-rdf-syntax-ns#type
</ins></code>:
<ol class="algorithm">
<li>
<del class="diff-old">Look
up
the
target
node
label
in
the
processed
labels
map
and
if
a
mapping
exists,
update
the
adjacent
serialized
labels
map
where
the
key
is
the
value
in
the
serialization
map
(
serialization
map
is
used,
but
should
it
be
directed
serialization
map
,
outgoing
serialization
map
or
incoming
serialization
map
?
)
and
the
</del>
<ins class="diff-chg">If
</ins><em>
value
<del class="diff-old">is
the
target
node
label
.
Otherwise,
add
the
target
node
label
to
the
adjacent
unserialized
labels
list
.
Set
the
maximum
serialization
combinations
to
1
or
the
length
of
the
adjacent
unserialized
labels
list
,
whichever
is
greater.
While
the
maximum
serialization
combinations
is
greater
than
0
,
perform
the
Combinatorial
Serialization
Algorithm
passing
the
node
state
,
the
mapping
state
for
the
first
iteration
and
a
copy
</del>
</em>
<ins class="diff-chg">has
an
key/value
pair
</ins>
of
<del class="diff-old">it
for
each
subsequent
iteration,
the
generated
serialization
label
,
the
direction
,
the
adjacent
serialized
labels
map
,
and
the
adjacent
unserialized
labels
list
.
Decrement
the
maximum
serialization
combinations
by
</del>
<code>
<del class="diff-old">1
</del>
<ins class="diff-chg">@type
</ins>
</code>
<del class="diff-old">for
each
iteration.
3.8.10
Serialization
Label
Generation
Algorithm
The
algorithm
generates
a
serialization
label
given
a
label
</del>
and
<del class="diff-old">a
mapping
state
and
returns
the
serialization
label
.
If
the
label
is
already
in
the
serialization
labels
map
,
return
its
associated
value.
(
serialization
labels
map
is
used,
but
should
it
be
directed
serialization
map
</del>
<ins class="diff-chg">an
</ins><a class="tref internalDFN" title="array" href="#dfn-array"><ins class="diff-chg">
array
</ins>
</a>,
<del class="diff-old">outgoing
serialization
map
or
incoming
serialization
map
?
)
If
the
label
starts
with
</del>
<ins class="diff-chg">append
</ins>
the
string
<del class="diff-old">_:c14n
,
the
serialization
label
</del>
<ins class="diff-chg">representation
of
</ins><a class="tref internalDFN" title="object" href="#dfn-object"><ins class="diff-chg">
object
</ins>
</a>
<del class="diff-old">is
the
letter
c
followed
by
the
number
</del>
<ins class="diff-chg">to
</ins>
that
<del class="diff-old">follows
_:c14n
in
the
label
.
</del>
<ins class="diff-chg">array.
</ins>
</li>
<li>
Otherwise,
<del class="diff-old">the
serialization
label
is
the
letter
s
followed
by
the
string
</del>
<ins class="diff-chg">if
</ins><em>
value
</em>
<ins class="diff-new">has
an
key
</ins>
of
<del class="diff-old">mapping
counter
.
Increment
the
mapping
counter
by
</del>
<code>
<del class="diff-old">1
.
Create
</del>
<ins class="diff-chg">@type
</ins></code>,<ins class="diff-chg">
replace
that
value
with
</ins>
a
new
<del class="diff-old">key-value
pair
in
the
serialization
labels
map
where
the
key
is
the
label
and
</del>
<ins class="diff-chg">array
containing
</ins>
the
<ins class="diff-new">existing
</ins>
value
<del class="diff-old">is
the
generated
serialization
label
.
3.8.11
Combinatorial
Serialization
Algorithm
The
combinatorial
serialization
algorithm
takes
a
node
state
,
a
mapping
state
,
a
serialization
label
,
a
direction
,
a
adjacent
serialized
labels
map
,
</del>
and
a
<del class="diff-old">adjacent
unserialized
labels
list
as
inputs
and
generates
the
lexicographically
least
serialization
</del>
<ins class="diff-chg">string
representation
</ins>
of
<del class="diff-old">nodes
relating
to
the
node
reference
.
If
the
adjacent
unserialized
labels
list
is
not
empty:
Copy
the
adjacent
serialized
labels
map
to
the
adjacent
serialized
labels
map
copy
.
</del>
<em>
<ins class="diff-chg">object
</ins></em>.
</li>
<li>
<del class="diff-old">Remove
the
first
unserialized
label
from
the
adjacent
unserialized
labels
list
and
</del>
<ins class="diff-chg">Otherwise,
</ins>
create
a
new
<del class="diff-old">new
serialization
label
according
to
the
Serialization
Label
Generation
Algorithm
.
Create
a
new
key-value
mapping
</del>
<ins class="diff-chg">entry
</ins>
in
<del class="diff-old">the
adjacent
serialized
labels
map
copy
where
the
key
is
the
new
serialization
label
and
the
</del>
value
<del class="diff-old">is
the
unserialized
label
.
Set
the
maximum
serialization
rotations
to
1
or
the
length
of
the
adjacent
unserialized
labels
list
,
whichever
is
greater.
While
the
maximum
serialization
rotations
is
greater
than
0
:
Recursively
perform
the
Combinatorial
Serialization
Algorithm
passing
the
mapping
state
for
the
first
iteration
of
the
loop,
and
a
copy
of
it
for
each
subsequent
iteration.
Rotate
the
elements
in
the
adjacent
unserialized
labels
list
by
shifting
each
of
them
once
to
the
right,
moving
the
element
at
the
end
of
the
list
to
the
beginning
of
the
list.
Decrement
the
maximum
serialization
rotations
by
1
for
each
iteration.
If
the
adjacent
unserialized
labels
list
is
empty:
Create
a
list
of
keys
from
the
keys
in
the
adjacent
serialized
labels
map
and
sort
it
lexicographically.
Add
</del>
<ins class="diff-chg">with
</ins>
a
<del class="diff-old">key-value
pair
to
the
adjacent
info
map
where
the
</del>
key
<del class="diff-old">is
the
serialization
label
and
the
value
is
an
object
containing
the
node
reference
's
label,
the
list
</del>
of
<del class="diff-old">keys
and
the
adjacent
serialized
labels
map
.
Update
the
serialization
string
according
to
the
Mapping
Serialization
Algorithm
.
If
the
direction
is
</del>
<code>
<del class="diff-old">outgoing
direction
</del>
<ins class="diff-chg">@type
</ins>
</code>
<del class="diff-old">then
directed
serialization
refers
to
the
outgoing
serialization
and
the
directed
serialization
map
refers
to
the
outgoing
serialization
map
,
otherwise
it
refers
to
the
incoming
serialization
</del>
and
<del class="diff-old">the
directed
serialization
map
refers
to
the
incoming
serialization
map
.
Compare
the
serialization
string
to
the
directed
serialization
according
to
the
Serialization
Comparison
Algorithm
.
If
the
serialization
string
is
less
than
or
equal
to
the
directed
serialization
:
For
each
</del>
value
<del class="diff-old">in
the
list
of
keys
,
run
the
Node
Serialization
Algorithm
.
Update
the
serialization
string
according
to
the
Mapping
Serialization
Algorithm
.
Compare
the
serialization
string
to
the
directed
serialization
again
and
if
it
is
less
than
or
equal
and
the
length
of
the
serialization
string
is
greater
than
or
equal
to
the
length
of
the
directed
serialization
,
then
set
the
directed
serialization
to
the
serialization
string
and
set
the
directed
serialization
map
to
the
serialized
labels
map
.
3.8.12
Serialization
Comparison
Algorithm
The
serialization
comparison
algorithm
takes
two
serializations,
alpha
and
beta
and
returns
either
which
of
the
two
is
less
than
the
other
or
that
they
are
equal.
Whichever
serialization
is
an
empty
string
is
greater.
If
they
are
both
empty
strings,
they
are
equal.
Return
the
result
of
</del>
<ins class="diff-chg">being
</ins>
a
<del class="diff-old">lexicographical
comparison
of
alpha
and
beta
up
to
the
number
of
characters
in
the
shortest
of
the
two
serializations.
3.8.13
Mapping
Serialization
Algorithm
The
mapping
serialization
algorithm
incrementally
updates
the
serialization
</del>
string
<del class="diff-old">in
a
mapping
state
.
If
the
key
stack
is
not
empty:
Pop
the
serialization
key
info
off
</del>
<ins class="diff-chg">representation
</ins>
of
<del class="diff-old">the
key
stack
.
</del>
<em>
<ins class="diff-chg">object
</ins></em>.
</li>
<del class="diff-old">For
each
serialization
key
in
the
serialization
key
info
array,
starting
at
the
serialization
key
index
from
the
serialization
key
info
:
If
the
serialization
key
is
not
in
the
adjacent
info
map
,
push
the
serialization
key
info
onto
the
key
stack
and
exit
from
this
loop.
</del>
</ol>
</li>
<li>
<del class="diff-old">If
the
serialization
key
is
a
key
in
serialized
keys
,
a
cycle
has
been
detected.
Append
the
concatenation
of
the
_
character
and
the
serialization
</del>
<ins class="diff-chg">Otherwise,
let
</ins><em>
key
<del class="diff-old">to
</del>
</em>
<ins class="diff-chg">by
</ins>
the
<del class="diff-old">serialization
</del>
string
<del class="diff-old">.
Otherwise,
serialize
all
outgoing
</del>
<ins class="diff-chg">representation
of
</ins><em><ins class="diff-chg">
predicate
</ins></em>
and
<del class="diff-old">incoming
edges
</del>
<ins class="diff-chg">let
</ins><em><ins class="diff-chg">
object
representation
</ins></em><ins class="diff-chg">
be
</ins><em><ins class="diff-chg">
object
</ins></em><ins class="diff-chg">
represented
</ins>
in
<del class="diff-old">the
related
node
by
performing
the
following
steps:
Mark
the
serialization
key
</del>
<ins class="diff-chg">expanded
form
</ins>
as
<del class="diff-old">having
been
processed
by
adding
a
new
key-value
pair
to
serialized
keys
where
the
key
is
the
serialization
key
and
the
value
is
true
.
Set
the
serialization
fragment
to
the
value
of
the
serialization
key
.
Set
the
adjacent
info
to
the
value
of
the
serialization
key
</del>
<ins class="diff-chg">described
</ins>
in
<del class="diff-old">the
adjacent
info
map
.
Set
the
adjacent
node
label
to
the
node
label
from
the
adjacent
info
map
</del>
<a href="#value-expansion">
<ins class="diff-chg">Value
Expansion
</ins>
</a>.
</li>
<li>
If
<del class="diff-old">a
mapping
for
the
adjacent
node
label
exists
in
the
map
of
all
labels
:
Append
the
result
of
the
Label
Serialization
Algorithm
to
the
serialization
fragment
.
map
of
all
labels
referenced
but
not
defined.
Append
all
of
the
keys
in
the
adjacent
info
map
to
the
serialization
fragment
.
Append
the
serialization
fragment
to
the
serialization
string
.
Push
a
new
key
info
object
containing
the
keys
from
the
adjacent
info
map
and
</del>
<em>
<ins class="diff-chg">value
</ins></em><ins class="diff-chg">
has
</ins>
an
<del class="diff-old">index
</del>
<ins class="diff-chg">key/value
pair
</ins>
of
<del class="diff-old">0
onto
the
</del>
<em>
key
<del class="diff-old">stack
.
Recursively
update
the
serialization
string
according
to
the
Mapping
Serialization
Algorithm
.
3.8.14
Label
Serialization
Algorithm
The
label
serialization
algorithm
serializes
information
about
a
node
that
has
been
assigned
a
particular
serialization
label
.
Initialize
the
label
serialization
to
</del>
</em>
<ins class="diff-chg">and
</ins>
an
<del class="diff-old">empty
string.
Append
the
[
character
to
the
label
serialization
.
Append
all
properties
to
the
label
serialization
by
processing
each
key-value
pair
in
the
node
reference
</del>
<a class="tref internalDFN" title="array" href="#dfn-array">
<ins class="diff-chg">array
</ins>
</a>,
<del class="diff-old">excluding
the
@subject
property.
The
keys
should
be
processed
in
lexicographical
order
and
their
associated
values
should
be
processed
in
the
order
produced
by
the
Object
Comparison
Algorithm
:
Build
a
string
using
the
pattern
&lt;
KEY
&gt;
where
KEY
is
the
current
key.
Append
string
</del>
<ins class="diff-chg">append
</ins><em><ins class="diff-chg">
object
representation
</ins></em>
to
<del class="diff-old">the
label
serialization
.
</del>
<ins class="diff-chg">that
array.
</ins>
</li>
<li>
<del class="diff-old">The
</del>
<ins class="diff-chg">Otherwise,
if
</ins><em>
value
<del class="diff-old">may
be
a
single
object
or
</del>
</em>
<ins class="diff-chg">has
</ins>
an
<del class="diff-old">array
of
objects.
Process
all
</del>
<ins class="diff-chg">key
</ins>
of
<del class="diff-old">the
objects
that
are
associated
with
the
key,
building
an
object
string
for
each
item:
If
the
object
contains
an
@iri
</del>
<em>
key
<del class="diff-old">with
a
value
</del>
</em>,
<ins class="diff-chg">replace
</ins>
that
<del class="diff-old">starts
with
_:
,
set
the
object
string
to
the
value
_:
.
If
the
value
does
not
start
with
_:
,
build
the
object
string
using
the
pattern
&lt;
IRI
&gt;
where
IRI
is
the
</del>
value
<del class="diff-old">associated
</del>
with
<del class="diff-old">the
@iri
key.
If
the
object
contains
</del>
a
<del class="diff-old">@literal
key
and
a
@datatype
key,
build
the
object
string
using
the
pattern
&quot;
LITERAL
&quot;^^&lt;
DATATYPE
&gt;
where
LITERAL
is
the
value
associated
with
the
@literal
key
and
DATATYPE
is
</del>
<ins class="diff-chg">new
array
containing
</ins>
the
<ins class="diff-new">existing
</ins>
value
<del class="diff-old">associated
with
the
@datatype
key.
If
the
object
contains
a
@literal
key
</del>
and
<del class="diff-old">a
@language
key,
build
the
</del>
<em>
object
<del class="diff-old">string
using
the
pattern
&quot;
LITERAL
&quot;@
LANGUAGE
where
LITERAL
is
the
value
associated
with
the
@literal
key
and
LANGUAGE
is
the
value
associated
with
the
@language
key.
</del>
<ins class="diff-chg">representation
</ins></em>.
</li>
<li>
Otherwise,
<del class="diff-old">the
value
is
</del>
<ins class="diff-chg">create
</ins>
a
<del class="diff-old">string.
Build
the
object
string
using
the
pattern
&quot;
LITERAL
&quot;
where
LITERAL
is
the
</del>
<ins class="diff-chg">new
entry
in
</ins>
value
<del class="diff-old">associated
</del>
with
<del class="diff-old">the
current
key.
If
this
is
the
second
iteration
of
the
loop,
append
</del>
a
<del class="diff-old">|
separator
character
to
the
label
serialization
.
Append
the
object
string
to
the
label
serialization
.
Append
the
]
character
to
the
label
serialization
.
Append
the
[
character
to
the
label
serialization
.
Append
all
incoming
references
for
the
current
label
to
the
label
serialization
by
processing
all
</del>
<ins class="diff-chg">key
</ins>
of
<del class="diff-old">the
items
associated
with
the
incoming
list
:
Build
a
reference
string
using
the
pattern
&lt;
PROPERTY
&gt;
&lt;
REFERER
&gt;
where
PROPERTY
is
the
property
associated
with
the
incoming
reference
</del>
<em>
<ins class="diff-chg">key
</ins></em>
and
<del class="diff-old">REFERER
is
either
the
subject
of
the
node
referring
to
the
label
in
the
incoming
reference
or
_:
if
REFERER
begins
with
_:
.
If
this
is
the
second
iteration
of
the
loop,
append
a
|
separator
character
to
the
label
serialization
.
Append
the
reference
string
to
the
label
serialization
.
</del>
<em>
<ins class="diff-chg">object
representation
</ins></em>.
</li>
</ol>
</li>
<del class="diff-old">Append
the
]
character
to
the
label
serialization
.
Append
all
adjacent
node
labels
to
the
label
serialization
by
concatenating
the
string
value
for
all
of
them,
one
after
the
other,
to
the
label
serialization
.
adjacent
node
labels
referenced
but
not
defined.
</del>
<li>
<del class="diff-old">Push
the
adjacent
node
labels
onto
the
key
stack
and
append
the
result
of
the
Mapping
Serialization
Algorithm
to
</del>
<ins class="diff-chg">Return
</ins><em><ins class="diff-chg">
array
</ins></em><ins class="diff-chg">
as
</ins>
the
<del class="diff-old">label
serialization
.
</del>
<ins class="diff-chg">normalized
graph
representation.
</ins>
</li>
</ol>
</div>
</div>
<div id="data-round-tripping" class="section">
<h3>
<span class="secno">
<del class="diff-old">3.9
</del>
<ins class="diff-chg">3.12
</ins>
</span>
Data
Round
Tripping
</h3>
<p>
When
normalizing
<strong>
xsd:double
</strong>
values,
implementers
<em class="rfc2119" title="must">
must
</em>
ensure
that
the
normalized
value
is
a
string.
In
order
to
generate
the
string
from
a
<strong>
double
</strong>
value,
output
equivalent
to
the
<code>
<del class="diff-old">printf(&quot;%1.6e&quot;,
</del>
<ins class="diff-chg">printf("%1.6e",
</ins>
value)
</code>
function
in
C
<em class="rfc2119" title="must">
must
</em>
be
used
where
<strong>
<del class="diff-old">&quot;%1.6e&quot;
</del>
<ins class="diff-chg">"%1.6e"
</ins>
</strong>
is
the
string
formatter
and
<strong>
value
</strong>
is
the
value
to
be
converted.
</p>
<p>
To
convert
the
a
double
value
in
JavaScript,
implementers
can
use
the
following
snippet
of
code:
</p>
<del class="diff-old">// the variable 'value' below is the JavaScript native double value that is to be converted
</del>
<pre class="example">// the variable 'value' below is the JavaScript native double value that is to be converted
(value).toExponential(6).replace(/(e(?:\+|-))([0-9])$/,
'$10$2')
</pre>
<p class="note">
When
data
needs
to
be
normalized,
JSON-LD
authors
should
not
use
values
that
are
going
to
undergo
automatic
conversion.
This
is
due
to
the
lossy
nature
of
<strong>
xsd:double
</strong>
values.
</p>
<p class="note">
Some
JSON
serializers,
such
as
PHP's
native
implementation,
backslash-escapes
the
forward
slash
character.
For
example,
the
value
<code>
http://example.com/
</code>
would
be
serialized
as
<code>
http:\/\/example.com\/
</code>
in
some
versions
of
PHP.
This
is
problematic
when
generating
a
byte
stream
for
processes
such
as
normalization.
There
is
no
need
to
backslash-escape
forward-slashes
in
JSON-LD.
To
aid
interoperability
between
JSON-LD
processors,
a
JSON-LD
serializer
<em class="rfc2119" title="must not">
must
not
</em>
backslash-escape
forward
slashes.
</p>
<p class="issue">
Round-tripping
data
can
be
problematic
if
we
mix
and
match
<del class="diff-old">@coerce
</del>
<ins class="diff-chg">coercion
</ins>
rules
with
JSON-native
datatypes,
like
integers.
Consider
the
following
code
example:
</p>
<del class="diff-old">var myObj = { &quot;@context&quot; : {
                &quot;number&quot; : &quot;http://example.com/vocab#number&quot;,
                &quot;@coerce&quot;: {
                   &quot;xsd:nonNegativeInteger&quot;: &quot;number&quot;
                }
              },
              &quot;number&quot; : 42 };
// Map the language-native object to JSON-LD
var jsonldText = jsonld.normalize(myObj);
// Convert the normalized object back to a JavaScript object
</del>
<pre class="example">var myObj = { "@context" : {
<ins class="diff-chg">                "number" : {
                  "@id": "http://example.com/vocab#number",
                  "@type": "xsd:nonNegativeInteger"
                }
              },
              "number" : 42 };

// Map the language-native object to JSON-LD
var jsonldText = jsonld.normalize(myObj);

// Convert the normalized object back to a JavaScript object
</ins>
var
myObj2
=
jsonld.parse(jsonldText);
</pre>
<p class="issue">
At
this
point,
myObj2
and
myObj
will
have
different
values
for
the
<del class="diff-old">&quot;number&quot;
</del>
<ins class="diff-chg">"number"
</ins>
value.
myObj
will
be
the
number
42,
while
myObj2
will
be
the
string
<del class="diff-old">&quot;42&quot;.
</del>
<ins class="diff-chg">"42".
</ins>
This
type
of
data
round-tripping
error
can
bite
developers.
We
are
currently
wondering
if
having
a
<del class="diff-old">&quot;coerce
validation&quot;
</del>
<ins class="diff-chg">"coercion
validation"
</ins>
phase
in
the
parsing/normalization
phases
would
be
a
good
idea.
It
would
prevent
data
round-tripping
issues
like
the
one
mentioned
above.
</p>
</div>
<div id="rdf-conversion" class="section">
<h3>
<span class="secno">
<del class="diff-old">3.10
</del>
<ins class="diff-chg">3.13
</ins>
</span>
RDF
Conversion
</h3>
<p>
A
JSON-LD
document
<em class="rfc2119" title="may">
may
</em>
be
converted
to
any
other
RDF-compatible
document
format
using
the
algorithm
specified
in
this
section.
</p>
<p>
The
JSON-LD
Processing
Model
describes
processing
rules
for
extracting
RDF
from
a
JSON-LD
document.
Note
that
many
uses
of
JSON-LD
may
not
require
generation
of
RDF.
</p>
<p>
The
processing
algorithm
described
in
this
section
is
provided
in
order
to
demonstrate
how
one
might
implement
a
JSON-LD
to
RDF
processor.
Conformant
implementations
are
only
required
to
produce
the
same
type
and
number
of
triples
during
the
output
process
and
are
not
required
to
implement
the
algorithm
exactly
as
described.
</p>
<del class="diff-old">The
RDF
Conversion
Algorithm
is
a
work
in
progress.
</del>
<div class="informative section" id="overview">
<h4>
<span class="secno">
<del class="diff-old">3.10.1
</del>
<ins class="diff-chg">3.13.1
</ins>
</span>
Overview
</h4>
<p>
<em>
This
section
is
non-normative.
</em>
</p>
<p>
JSON-LD
is
intended
to
have
an
easy
to
parse
grammar
that
closely
models
existing
practice
in
using
JSON
for
describing
object
representations.
This
allows
the
use
of
existing
libraries
for
parsing
JSON.
</p>
<p>
As
with
other
grammars
used
for
describing
<a class="tref internalDFN" title="linked_data" href="#dfn-linked_data">
Linked
Data
</a>,
a
key
concept
is
that
of
a
<dfn title="resource" id="dfn-resource">
resource
<del class="diff-old">.
</del>
</dfn>.
Resources
may
be
of
three
basic
types:
<em>
<a class="tref internalDFN" title="iri" href="#dfn-iri">
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
</a>
</em>
s,
for
describing
externally
named
entities,
<em>
BNodes
</em>,
resources
for
which
an
external
name
does
not
exist,
or
is
not
known,
and
Literals,
which
describe
terminal
entities
such
as
strings,
dates
and
other
representations
having
a
lexical
representation
possibly
including
an
explicit
language
or
datatype.
</p>
<p>
An
Internationalized
Resource
Identifier
(
<dfn title="iri" id="dfn-iri">
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
</dfn>
),
as
described
in
[
<cite>
<a class="bibref" rel="biblioentry" href="#bib-RFC3987">
RFC3987
</a>
</cite>
],
is
a
mechanism
for
representing
unique
identifiers
on
the
web.
In
<a class="tref internalDFN" title="linked_data" href="#dfn-linked_data">
Linked
Data
</a>,
an
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
is
commonly
used
for
expressing
a
<a class="tref internalDFN" title="subject" href="#dfn-subject">
subject
</a>,
a
<a class="tref internalDFN" title="property" href="#dfn-property">
property
</a>
or
an
<a class="tref internalDFN" title="object" href="#dfn-object">
object
</a>.
</p>
<p>
Data
described
with
JSON-LD
may
be
considered
to
be
the
representation
of
a
graph
made
up
of
<a class="tref internalDFN" title="subject" href="#dfn-subject">
subject
</a>
and
<a class="tref internalDFN" title="object" href="#dfn-object">
object
</a>
<del class="diff-old">resources
</del>
<a class="tref internalDFN" title="resource" href="#dfn-resource">
<ins class="diff-chg">resource
</ins></a><ins class="diff-chg">
s
</ins>
related
via
a
<a class="tref internalDFN" title="property" href="#dfn-property">
property
</a>
<del class="diff-old">resource.
</del>
<a class="tref internalDFN" title="resource" href="#dfn-resource">
<ins class="diff-chg">resource
</ins></a>.
However,
specific
implementations
may
choose
to
operate
on
the
document
as
a
normal
JSON
description
of
objects
having
attributes.
</p>
</div>
<div id="rdf-conversion-algorithm-terms" class="section">
<h4>
<span class="secno">
<del class="diff-old">3.10.2
</del>
<ins class="diff-chg">3.13.2
</ins>
</span>
RDF
Conversion
Algorithm
Terms
</h4>
<dl>
<dt>
<dfn title="default_graph" id="dfn-default_graph">
default
graph
</dfn>
</dt>
<dd>
the
destination
graph
for
all
triples
generated
by
JSON-LD
markup.
</dd>
</dl>
</div>
<div id="rdf-conversion-algorithm" class="section">
<h4>
<span class="secno">
<del class="diff-old">3.10.3
</del>
<ins class="diff-chg">3.13.3
</ins>
</span>
RDF
Conversion
Algorithm
</h4>
<p>
The
algorithm
below
is
designed
for
in-memory
implementations
with
random
access
to
<a class="tref internalDFN" title="json_object" href="#dfn-json_object">
JSON
object
</a>
elements.
</p>
<p>
A
conforming
JSON-LD
processor
implementing
RDF
conversion
<em class="rfc2119" title="must">
must
</em>
implement
a
processing
algorithm
that
results
in
the
same
<a class="tref internalDFN" title="default_graph" href="#dfn-default_graph">
default
graph
</a>
that
the
following
algorithm
generates:
</p>
<ol class="algorithm">
<li id="processing-step-default-context">
Create
a
new
<a class="tref internalDFN" title="processor_state" href="#dfn-processor_state">
processor
state
</a>
with
with
the
<a class="tref internalDFN" title="active_context" href="#dfn-active_context">
active
context
</a>
set
to
the
<a class="tref internalDFN" title="initial_context" href="#dfn-initial_context">
initial
context
</a>
and
<a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">
active
subject
</a>
and
<a class="tref internalDFN" title="active_property" href="#dfn-active_property">
active
property
</a>
initialized
to
NULL.
</li>
<li id="processing-step-associative">
If
a
<a class="tref internalDFN" title="json_object" href="#dfn-json_object">
JSON
object
</a>
is
detected,
perform
the
following
steps:
<ol class="algorithm">
<li>
If
the
<a class="tref internalDFN" title="json_object" href="#dfn-json_object">
JSON
object
</a>
has
a
<code>
@context
</code>
key,
process
the
local
context
as
described
in
<a href="#context">
Context
</a>.
</li>
<li>
Create
a
<del class="diff-old">new
JSON
object
by
mapping
the
keys
from
</del>
<ins class="diff-chg">copy
of
</ins>
the
current
<a class="tref internalDFN" title="json_object" href="#dfn-json_object">
JSON
object
<del class="diff-old">using
the
active
context
to
new
</del>
</a>,
<ins class="diff-chg">changing
</ins>
keys
<del class="diff-old">using
the
associated
value
from
the
current
JSON
object
.
Repeat
the
mapping
until
no
entry
is
found
within
the
active
context
</del>
<ins class="diff-chg">that
map
to
JSON-LD
</ins><a class="tref internalDFN" title="keyword" href="#dfn-keyword"><ins class="diff-chg">
keyword
</ins>
</a>
<del class="diff-old">for
the
key.
</del>
<ins class="diff-chg">s
with
those
</ins><a class="tref internalDFN" title="keyword" href="#dfn-keyword"><ins class="diff-chg">
keyword
</ins></a><ins class="diff-chg">
s.
</ins>
Use
the
new
<a class="tref internalDFN" title="json_object" href="#dfn-json_object">
JSON
object
</a>
in
subsequent
steps.
</li>
<li>
If
the
<a class="tref internalDFN" title="json_object" href="#dfn-json_object">
JSON
object
</a>
has
<del class="diff-old">an
@iri
key,
set
the
active
object
by
performing
IRI
Expansion
on
the
associated
value.
Generate
a
triple
representing
the
active
subject
,
the
active
property
and
the
active
object
.
Return
the
active
object
to
the
calling
location.
@iri
really
just
behaves
the
same
as
@subject
,
consider
consolidating
them.
If
the
JSON
object
has
</del>
a
<code>
<del class="diff-old">@literal
</del>
<ins class="diff-chg">@value
</ins>
</code>
key,
set
the
<a class="tref internalDFN" title="active_object" href="#dfn-active_object">
active
object
</a>
to
a
literal
value
as
follows:
<ol class="algorithm">
<li>
as
a
<a class="tref internalDFN" title="typed_literal" href="#dfn-typed_literal">
typed
literal
</a>
if
the
<a class="tref internalDFN" title="json_object" href="#dfn-json_object">
JSON
object
</a>
contains
a
<code>
<del class="diff-old">@datatype
</del>
<ins class="diff-chg">@type
</ins>
</code>
key
after
performing
<a href="#iri-expansion">
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
Expansion
</a>
on
the
specified
<code>
<del class="diff-old">@datatype
</del>
<ins class="diff-chg">@type
</ins>
</code>.
</li>
<li>
otherwise,
as
a
<a class="tref internalDFN" title="plain_literal" href="#dfn-plain_literal">
plain
literal
</a>.
If
the
<a class="tref internalDFN" title="json_object" href="#dfn-json_object">
JSON
object
</a>
contains
a
<code>
@language
</code>
key,
use
it's
value
to
set
the
language
of
the
plain
literal.
</li>
<li>
<del class="diff-old">Generate
</del>
<ins class="diff-chg">If
the
neither
the
</ins><a class="tref internalDFN" title="active_subject" href="#dfn-active_subject"><ins class="diff-chg">
active
subject
</ins></a><ins class="diff-chg">
nor
the
</ins><a class="tref internalDFN" title="active_property" href="#dfn-active_property"><ins class="diff-chg">
active
property
</ins></a>,<ins class="diff-chg">
generate
</ins>
a
triple
representing
the
<a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">
active
subject
</a>,
the
<a class="tref internalDFN" title="active_property" href="#dfn-active_property">
active
property
</a>
and
the
<a class="tref internalDFN" title="active_object" href="#dfn-active_object">
active
object
</a>.
</li>
<li>
Return
the
<a class="tref internalDFN" title="active_object" href="#dfn-active_object">
active
object
</a>
to
the
calling
location.
</li>
</ol>
</li>
<li>
If
the
<a class="tref internalDFN" title="json_object" href="#dfn-json_object">
JSON
object
</a>
has
a
<code>
@list
</code>
key
and
the
value
is
an
<a class="tref internalDFN" title="array" href="#dfn-array">
array
</a>
process
the
value
as
a
list
<del class="diff-old">starting
at
Step
4
</del>
<ins class="diff-chg">as
described
in
</ins><a href="#list-conversion"><ins class="diff-chg">
List
Conversion
</ins>
</a>.
</li>
<li id="processing-step-subject">
If
the
<a class="tref internalDFN" title="json_object" href="#dfn-json_object">
JSON
object
</a>
has
a
<code>
<del class="diff-old">@subject
</del>
<ins class="diff-chg">@id
</ins>
</code>
key:
<ol class="algorithm">
<li>
If
the
value
is
a
<a class="tref internalDFN" title="string" href="#dfn-string">
string
</a>,
set
the
<a class="tref internalDFN" title="active_object" href="#dfn-active_object">
active
object
</a>
to
the
result
of
performing
<a href="#iri-expansion">
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
Expansion
</a>.
Generate
a
triple
representing
the
<a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">
active
subject
</a>,
the
<a class="tref internalDFN" title="active_property" href="#dfn-active_property">
active
property
</a>
and
the
<a class="tref internalDFN" title="active_object" href="#dfn-active_object">
active
object
</a>.
Set
the
<a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">
active
subject
</a>
to
the
<a class="tref internalDFN" title="active_object" href="#dfn-active_object">
active
object
</a>.
</li>
<li>
Create
a
new
<a class="tref internalDFN" title="processor_state" href="#dfn-processor_state">
processor
state
</a>
copies
of
the
<a class="tref internalDFN" title="active_context" href="#dfn-active_context">
active
context
</a>,
<a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">
active
subject
</a>
and
<a class="tref internalDFN" title="active_property" href="#dfn-active_property">
active
property
</a>.
<ol class="algorithm">
<li>
<del class="diff-old">If
the
active
property
is
the
target
of
a
@list
coercion,
and
the
value
is
an
array
,
process
the
value
as
a
list
starting
at
Step
4
.
Otherwise,
process
</del>
<ins class="diff-chg">Process
</ins>
the
value
starting
at
<a href="#processing-step-associative">
Step
2
</a>.
</li>
<li>
Proceed
using
the
previous
<a class="tref internalDFN" title="processor_state" href="#dfn-processor_state">
processor
state
</a>.
</li>
</ol>
</li>
</ol>
</li>
<li>
If
the
<a class="tref internalDFN" title="json_object" href="#dfn-json_object">
JSON
object
</a>
does
not
have
a
<code>
<del class="diff-old">@subject
</del>
<ins class="diff-chg">@id
</ins>
</code>
key,
set
the
<a class="tref internalDFN" title="active_object" href="#dfn-active_object">
active
object
</a>
to
newly
generated
<a class="tref internalDFN" title="blank_node" href="#dfn-blank_node">
blank
node
<del class="diff-old">identifier
</del>
</a>.
Generate
a
triple
representing
the
<a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">
active
subject
</a>,
the
<a class="tref internalDFN" title="active_property" href="#dfn-active_property">
active
property
</a>
and
the
<a class="tref internalDFN" title="active_object" href="#dfn-active_object">
active
object
</a>.
Set
the
<a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">
active
subject
</a>
to
the
<a class="tref internalDFN" title="active_object" href="#dfn-active_object">
active
object
</a>.
</li>
<li>
For
each
key
in
the
<a class="tref internalDFN" title="json_object" href="#dfn-json_object">
JSON
object
</a>
that
has
not
already
been
processed,
perform
the
following
steps:
<ol class="algorithm">
<li>
If
the
key
is
<code>
@type
</code>,
set
the
<a class="tref internalDFN" title="active_property" href="#dfn-active_property">
active
property
</a>
to
<code>
rdf:type
</code>.
</li>
<li>
Otherwise,
set
the
<a class="tref internalDFN" title="active_property" href="#dfn-active_property">
active
property
</a>
to
the
result
of
performing
<a href="#iri-expansion">
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
Expansion
</a>
on
the
key.
</li>
<li>
<del class="diff-old">Create
</del>
<ins class="diff-chg">If
the
</ins><a class="tref internalDFN" title="active_property" href="#dfn-active_property"><ins class="diff-chg">
active
property
</ins></a><ins class="diff-chg">
is
the
target
of
a
</ins><code><ins class="diff-chg">
@list
</ins></code><ins class="diff-chg">
coercion,
and
the
value
is
an
</ins><a class="tref internalDFN" title="array" href="#dfn-array"><ins class="diff-chg">
array
</ins></a>,<ins class="diff-chg">
process
the
value
as
a
list
as
described
in
in
</ins><a href="#list-conversion"><ins class="diff-chg">
List
Conversion
</ins></a>.</li><li><ins class="diff-chg">
Otherwise,
create
</ins>
a
new
<a class="tref internalDFN" title="processor_state" href="#dfn-processor_state">
processor
state
</a>
copies
of
the
<a class="tref internalDFN" title="active_context" href="#dfn-active_context">
active
context
</a>,
<a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">
active
subject
</a>
and
<a class="tref internalDFN" title="active_property" href="#dfn-active_property">
active
property
</a>
and
process
the
value
starting
at
<a href="#processing-step-associative">
Step
2
</a>
and
proceed
using
the
previous
<a class="tref internalDFN" title="processor_state" href="#dfn-processor_state">
processor
state
</a>.
</li>
</ol>
</li>
<li>
Return
the
<a class="tref internalDFN" title="active_object" href="#dfn-active_object">
active
object
</a>
to
the
calling
location.
</li>
</ol>
</li>
<li>
If
a
regular
<a class="tref internalDFN" title="array" href="#dfn-array">
array
</a>
is
detected,
process
each
value
in
the
<a class="tref internalDFN" title="array" href="#dfn-array">
array
</a>
by
doing
the
following
returning
the
result
of
processing
the
last
value
in
the
<a class="tref internalDFN" title="array" href="#dfn-array">
array
</a>:
<ol class="algorithm">
<li>
Create
a
new
<a class="tref internalDFN" title="processor_state" href="#dfn-processor_state">
processor
state
</a>
using
copies
of
the
<a class="tref internalDFN" title="active_context" href="#dfn-active_context">
active
context
</a>,
<a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">
active
subject
</a>
and
<a class="tref internalDFN" title="active_property" href="#dfn-active_property">
active
property
</a>
and
process
the
value
starting
at
<a href="#processing-step-associative">
Step
2
</a>
then
proceed
using
the
previous
<a class="tref internalDFN" title="processor_state" href="#dfn-processor_state">
processor
state
</a>.
</li>
</ol>
</li>
<del class="diff-old">Generate
an
RDF
List
by
linking
each
element
of
the
list
using
rdf:first
and
rdf:next
,
terminating
the
list
with
rdf:nil
using
the
following
sequence:
If
the
list
has
no
element,
generate
a
triple
using
the
active
subject
,
active
property
and
rdf:nil
.
Otherwise,
generate
a
triple
using
using
the
active
subject
,
active
property
and
a
newly
generated
BNode
identified
as
first
blank
node
identifier
.
For
each
element
other
than
the
last
element
in
the
list:
Create
a
processor
state
using
the
active
context,
first
blank
node
identifier
as
the
active
subject
,
and
rdf:first
as
the
active
property
.
Unless
this
is
the
last
element
in
the
list,
generate
a
new
BNode
identified
as
rest
blank
node
identifier
,
otherwise
use
rdf:nil
.
Generate
a
new
triple
using
first
blank
node
identifier
,
rdf:rest
and
rest
blank
node
identifier
.
Set
first
blank
node
identifier
to
rest
blank
node
identifier
.
</del>
<li>
If
a
<a class="tref internalDFN" title="string" href="#dfn-string">
string
</a>
is
detected:
<ol class="algorithm">
<li>
If
the
<a class="tref internalDFN" title="active_property" href="#dfn-active_property">
active
property
</a>
is
the
target
of
a
<code>
<del class="diff-old">@iri
</del>
<ins class="diff-chg">@id
</ins>
</code>
coercion,
set
the
<a class="tref internalDFN" title="active_object" href="#dfn-active_object">
active
object
</a>
by
performing
<a href="#iri-expansion">
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
Expansion
</a>
on
the
string.
</li>
<li>
Otherwise,
if
the
<a class="tref internalDFN" title="active_property" href="#dfn-active_property">
active
property
</a>
is
the
target
of
coercion,
set
the
<a class="tref internalDFN" title="active_object" href="#dfn-active_object">
active
object
</a>
by
creating
a
<a class="tref internalDFN" title="typed_literal" href="#dfn-typed_literal">
typed
literal
</a>
using
the
string
and
the
coercion
key
as
the
datatype
<del class="diff-old">IRI.
</del>
<abbr title="Internationalized Resource Identifier">
<ins class="diff-chg">IRI
</ins></abbr>.
</li>
<li>
Otherwise,
set
the
<a class="tref internalDFN" title="active_object" href="#dfn-active_object">
active
object
</a>
to
a
<a class="tref internalDFN" title="plain_literal" href="#dfn-plain_literal">
plain
literal
</a>
value
created
from
the
string.
If
the
<a class="tref internalDFN" title="active_context" href="#dfn-active_context">
active
context
</a>
contains
a
<code>
language
</code>
key
with
a
non-
<code>
null
</code>
value,
use
it's
value
to
set
the
language
of
the
<a class="tref internalDFN" title="plain_literal" href="#dfn-plain_literal">
plain
literal
</a>.
</li>
</ol>
Generate
a
triple
representing
the
<a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">
active
subject
</a>,
the
<a class="tref internalDFN" title="active_property" href="#dfn-active_property">
active
property
</a>
and
the
<a class="tref internalDFN" title="active_object" href="#dfn-active_object">
active
object
</a>.
</li>
<li>
If
a
<a class="tref internalDFN" title="number" href="#dfn-number">
number
</a>
is
detected,
generate
a
<a class="tref internalDFN" title="typed_literal" href="#dfn-typed_literal">
typed
literal
</a>
using
a
string
representation
of
the
value
with
datatype
set
to
either
<code>
xsd:integer
</code>
or
<code>
xsd:double
</code>,
depending
on
if
the
value
contains
a
fractional
and/or
an
exponential
component.
Generate
a
triple
using
the
<a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">
active
subject
</a>,
<a class="tref internalDFN" title="active_property" href="#dfn-active_property">
active
property
</a>
and
the
generated
typed
literal.
</li>
<li>
Otherwise,
if
<strong>
true
</strong>
or
<strong>
false
</strong>
is
detected,
generate
a
triple
using
the
<a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">
active
subject
</a>,
<a class="tref internalDFN" title="active_property" href="#dfn-active_property">
active
property
</a>
and
a
<a class="tref internalDFN" title="typed_literal" href="#dfn-typed_literal">
typed
literal
</a>
value
created
from
the
string
representation
of
the
value
with
datatype
set
to
<code>
xsd:boolean
</code>.
</li>
</ol>
</div>
<div id="list-conversion" class="section">
<h4>
<span class="secno">
<del class="diff-old">3.10.4
</del>
<ins class="diff-chg">3.13.4
</ins>
</span>
<del class="diff-old">Acknowledgements
</del>
<ins class="diff-chg">List
Conversion
</ins>
</h4>
<p>
<ins class="diff-new">List
Conversion
is
the
process
of
taking
an
</ins><a class="tref internalDFN" title="array" href="#dfn-array"><ins class="diff-new">
array
</ins></a><ins class="diff-new">
of
values
and
adding
them
to
a
newly
created
</ins><cite><a href="http://www.w3.org/TR/rdf-schema/#ch_collectionvocab"><ins class="diff-new">
RDF
Collection
</ins></a></cite><ins class="diff-new">
(see
[
</ins><cite><a class="bibref" rel="biblioentry" href="#bib-RDF-SCHEMA"><ins class="diff-new">
RDF-SCHEMA
</ins></a></cite><ins class="diff-new">
])
by
linking
each
element
of
the
list
using
</ins><code><ins class="diff-new">
rdf:first
</ins></code><ins class="diff-new">
and
</ins><code><ins class="diff-new">
rdf:next
</ins></code>,<ins class="diff-new">
terminating
the
list
with
</ins><code><ins class="diff-new">
rdf:nil
</ins></code><ins class="diff-new">
using
the
following
sequence:
</ins></p><p><ins class="diff-new">
The
algorithm
is
invoked
with
an
</ins><a class="tref internalDFN" title="array" href="#dfn-array"><ins class="diff-new">
array
</ins></a><em><ins class="diff-new">
array
</ins></em>,<ins class="diff-new">
the
</ins><a class="tref internalDFN" title="active_property" href="#dfn-active_property"><ins class="diff-new">
active
property
</ins></a>,<ins class="diff-new">
and
the
</ins><a class="tref internalDFN" title="active_context" href="#dfn-active_context"><ins class="diff-new">
active
context
</ins></a><ins class="diff-new">
and
returns
a
value
to
be
used
as
an
</ins><a class="tref internalDFN" title="active_object" href="#dfn-active_object"><ins class="diff-new">
active
object
</ins></a>.</p><div class="note"><ins class="diff-new">
This
algorithm
does
not
support
lists
containing
lists.
</ins></div><ol class="algorithm"><li><ins class="diff-new">
If
</ins><em><ins class="diff-new">
array
</ins></em><ins class="diff-new">
is
empty
return
</ins><code><ins class="diff-new">
rdf:nil
</ins></code>.</li><li><ins class="diff-new">
Otherwise,
generate
a
triple
using
using
the
</ins><a class="tref internalDFN" title="active_subject" href="#dfn-active_subject"><ins class="diff-new">
active
subject
</ins></a>,<a class="tref internalDFN" title="active_property" href="#dfn-active_property"><ins class="diff-new">
active
property
</ins></a><ins class="diff-new">
and
a
newly
generated
BNode
identified
as
</ins><em><ins class="diff-new">
first
</ins><a class="tref internalDFN" title="blank_node" href="#dfn-blank_node"><ins class="diff-new">
blank
node
</ins></a></em>.</li><li><ins class="diff-new">
For
each
element
in
</ins><em><ins class="diff-new">
array
</ins></em><ins class="diff-new">
other
than
the
last
element:
</ins><ol class="algorithm"><li><ins class="diff-new">
Create
a
processor
state
using
the
</ins><a class="tref internalDFN" title="active_context" href="#dfn-active_context"><ins class="diff-new">
active
context
</ins></a>,<em><ins class="diff-new">
first
</ins><a class="tref internalDFN" title="blank_node" href="#dfn-blank_node"><ins class="diff-new">
blank
node
</ins></a></em><ins class="diff-new">
as
the
</ins><a class="tref internalDFN" title="active_subject" href="#dfn-active_subject"><ins class="diff-new">
active
subject
</ins></a>,<ins class="diff-new">
and
</ins><code><ins class="diff-new">
rdf:first
</ins></code><ins class="diff-new">
as
the
</ins><a class="tref internalDFN" title="active_property" href="#dfn-active_property"><ins class="diff-new">
active
property
</ins></a>.<ol class="algorithm"><li><ins class="diff-new">
Process
the
value
starting
at
</ins><a href="#processing-step-associative"><ins class="diff-new">
Step
2
</ins></a>.</li><li><ins class="diff-new">
Proceed
using
the
previous
</ins><a class="tref internalDFN" title="processor_state" href="#dfn-processor_state"><ins class="diff-new">
processor
state
</ins></a>.</li></ol></li><li><ins class="diff-new">
Unless
this
is
the
last
element
in
</ins><em><ins class="diff-new">
array
</ins></em>,<ins class="diff-new">
generate
a
new
BNode
identified
as
</ins><em><ins class="diff-new">
rest
</ins><a class="tref internalDFN" title="blank_node" href="#dfn-blank_node"><ins class="diff-new">
blank
node
</ins></a></em>,<ins class="diff-new">
otherwise
use
</ins><code><ins class="diff-new">
rdf:nil
</ins></code>.</li><li><ins class="diff-new">
Generate
a
new
triple
using
</ins><em><ins class="diff-new">
first
</ins><a class="tref internalDFN" title="blank_node" href="#dfn-blank_node"><ins class="diff-new">
blank
node
</ins></a></em>,<code><ins class="diff-new">
rdf:rest
</ins></code><ins class="diff-new">
and
</ins><em><ins class="diff-new">
rest
</ins><a class="tref internalDFN" title="blank_node" href="#dfn-blank_node"><ins class="diff-new">
blank
node
</ins></a></em>.</li><li><ins class="diff-new">
Set
</ins><em><ins class="diff-new">
first
</ins><a class="tref internalDFN" title="blank_node" href="#dfn-blank_node"><ins class="diff-new">
blank
node
</ins></a></em><ins class="diff-new">
to
</ins><em><ins class="diff-new">
rest
</ins><a class="tref internalDFN" title="blank_node" href="#dfn-blank_node"><ins class="diff-new">
blank
node
</ins></a></em>.</li><li><ins class="diff-new">
Return
</ins><em><ins class="diff-new">
first
</ins><a class="tref internalDFN" title="blank_node" href="#dfn-blank_node"><ins class="diff-new">
blank
node
</ins></a></em>.</li></ol></li></ol></div></div></div><div class="appendix section" id="acknowledgements"><h2><span class="secno"><ins class="diff-new">
A.
</ins></span><ins class="diff-new">
Acknowledgements
</ins></h2><p>
The
editors
would
like
to
thank
Mark
Birbeck,
who
provided
a
great
deal
of
the
initial
push
behind
the
JSON-LD
work
via
his
work
on
RDFj,
Dave
<del class="diff-old">Longley,
Dave
</del>
Lehn
and
Mike
Johnson
who
reviewed,
provided
feedback,
and
performed
several
implementations
of
the
specification,
and
Ian
Davis,
who
created
RDF/JSON.
Thanks
also
to
Nathan
Rixham,
Bradley
P.
Allen,
Kingsley
Idehen,
Glenn
McDonald,
Alexandre
Passant,
Danny
Ayers,
Ted
Thibodeau
Jr.,
Olivier
Grisel,
Niklas
<del class="diff-old">Lindström,
</del>
<ins class="diff-chg">Lindstr�m,
</ins>
Markus
Lanthaler,
and
Richard
Cyganiak
for
their
input
on
the
specification.
<del class="diff-old">Another
huge
thank
you
goes
out
to
Dave
Longley
who
designed
many
of
</del>
</p>
</div>
<div class="appendix section" id="appendix-b">
<h2>
<span class="secno">
<ins class="diff-chg">B.
</ins></span><ins class="diff-chg">
Initial
Context
</ins></h2><p><ins class="diff-chg">
The
</ins><a class="tref internalDFN" title="initial_context" href="#dfn-initial_context"><ins class="diff-chg">
initial
context
</ins></a><ins class="diff-chg">
is
defined
with
</ins>
the
<del class="diff-old">algorithms
used
</del>
<ins class="diff-chg">following
default
entries:
</ins></p><pre class="example">{
<ins class="diff-chg">
  "@context": {
    "http://www.w3.org/1999/02/22-rdf-syntax-ns#type": { "@type": "@id"}
  }
}
</ins></pre><p><ins class="diff-chg">
Processors
</ins><em class="rfc2119" title="must"><ins class="diff-chg">
must
</ins></em><ins class="diff-chg">
act
as
if
the
initial
context
is
defined
</ins>
in
<del class="diff-old">this
specification,
including
</del>
the
<del class="diff-old">normalization
algorithm
which
was
a
monumentally
difficult
design
challenge.
</del>
<ins class="diff-chg">outer-most
level
when
processing
JSON-LD
documents.
</ins></p><p class="issue"><ins class="diff-chg">
Should
we
define
other
default
prefixes?
</ins>
</p>
</div>
<div id="references" class="appendix section">
<h2>
<span class="secno">
<del class="diff-old">A.
</del>
<ins class="diff-chg">C.
</ins>
</span>
References
</h2>
<div id="normative-references" class="section">
<h3>
<span class="secno">
<del class="diff-old">A.1
</del>
<ins class="diff-chg">C.1
</ins>
</span>
Normative
references
</h3>
<dl class="bibliography">
<dt id="bib-JSON-LD">
[JSON-LD]
</dt>
<dd>
Manu
Sporny,
Gregg
<del class="diff-old">Kellogg,
et
al.
</del>
<ins class="diff-chg">Kellogg.
</ins>
<a href="http://json-ld.org/spec/latest/json-ld-syntax/">
<cite>
The
JSON-LD
Syntax
</cite>
</a>
Latest.
W3C
Editor's
Draft.
URL:
<a href="http://json-ld.org/spec/latest/json-ld-syntax/">
http://json-ld.org/spec/latest/json-ld-syntax/
</a>
</dd>
<dt id="bib-JSON-POINTER">
[JSON-POINTER]
</dt>
<dd>
P.
Bryan,
Ed.
<cite>
<a href="http://www.ietf.org/id/draft-pbryan-zyp-json-pointer-01.txt">
JSON
Pointer
</a>
</cite>
Latest.
IETF
Draft.
URL:
<a href="http://www.ietf.org/id/draft-pbryan-zyp-json-pointer-01.txt">
http://www.ietf.org/id/draft-pbryan-zyp-json-pointer-01.txt
</a>
</dd>
<dt id="bib-RDF-CONCEPTS">
[RDF-CONCEPTS]
</dt>
<dd>
Graham
Klyne;
Jeremy
J.
Carroll.
<a href="http://www.w3.org/TR/2004/REC-rdf-concepts-20040210">
<cite>
Resource
Description
Framework
(RDF):
Concepts
and
Abstract
Syntax.
</cite>
</a>
10
February
2004.
W3C
Recommendation.
URL:
<a href="http://www.w3.org/TR/2004/REC-rdf-concepts-20040210">
http://www.w3.org/TR/2004/REC-rdf-concepts-20040210
</a>
</dd>
<del class="diff-old">[RFC3986]
</del>
<dt id="bib-RDF-NORMALIZATION">
<ins class="diff-chg">[RDF-NORMALIZATION]
</ins>
</dt>
<dd>
<del class="diff-old">T.
Berners-Lee;
R.
Fielding;
L.
Masinter.
</del>
<ins class="diff-chg">Manu
Sporny,
Dave
Longley.
</ins><a href="http://json-ld.org/spec/latest/rdf-graph-normalization/">
<cite>
<del class="diff-old">Uniform
Resource
Identifier
(URI):
Generic
Syntax.
</del>
<ins class="diff-chg">RDF
Graph
Normalization
</ins>
</cite>
</a>
<del class="diff-old">January
2005.
Internet
RFC
3986.
</del>
<ins class="diff-chg">Latest.
W3C
Editor's
Draft.
</ins>
URL:
<del class="diff-old">http://www.ietf.org/rfc/rfc3986.txt
</del>
<a href="http://json-ld.org/spec/latest/rdf-graph-normalization/">
<ins class="diff-chg">http://json-ld.org/spec/latest/rdf-graph-normalization/
</ins></a></dd><dt id="bib-RDF-SCHEMA"><ins class="diff-chg">
[RDF-SCHEMA]
</ins></dt><dd><ins class="diff-chg">
Dan
Brickley;
Ramanathan
V.
Guha.
</ins><a href="http://www.w3.org/TR/2004/REC-rdf-schema-20040210"><cite><ins class="diff-chg">
RDF
Vocabulary
Description
Language
1.0:
RDF
Schema.
</ins></cite></a><ins class="diff-chg">
10
February
2004.
W3C
Recommendation.
URL:
</ins><a href="http://www.w3.org/TR/2004/REC-rdf-schema-20040210"><ins class="diff-chg">
http://www.w3.org/TR/2004/REC-rdf-schema-20040210
</ins>
</a>
</dd>
<dt id="bib-RFC3987">
[RFC3987]
</dt>
<dd>
M.
<del class="diff-old">Dürst;
</del>
<ins class="diff-chg">D�rst;
</ins>
M.
Suignard.
<a href="http://www.ietf.org/rfc/rfc3987.txt">
<cite>
Internationalized
Resource
Identifiers
(IRIs).
</cite>
</a>
January
2005.
Internet
RFC
3987.
URL:
<a href="http://www.ietf.org/rfc/rfc3987.txt">
http://www.ietf.org/rfc/rfc3987.txt
</a>
</dd>
<dt id="bib-RFC4627">
[RFC4627]
</dt>
<dd>
D.
Crockford.
<a href="http://www.ietf.org/rfc/rfc4627.txt">
<cite>
The
application/json
Media
Type
for
JavaScript
Object
Notation
(JSON)
</cite>
</a>
July
2006.
Internet
RFC
4627.
URL:
<a href="http://www.ietf.org/rfc/rfc4627.txt">
http://www.ietf.org/rfc/rfc4627.txt
</a>
</dd>
<dt id="bib-WEBIDL">
[WEBIDL]
</dt>
<dd>
Cameron
McCormack.
<a href="http://www.w3.org/TR/2011/WD-WebIDL-20110927/">
<cite>
Web
IDL.
</cite>
</a>
<del class="diff-old">19
December
2008.
</del>
<ins class="diff-chg">27
September
2011.
</ins>
W3C
Working
Draft.
(Work
in
progress.)
URL:
<del class="diff-old">http://www.w3.org/TR/2008/WD-WebIDL-20081219
</del>
<a href="http://www.w3.org/TR/2011/WD-WebIDL-20110927/">
<ins class="diff-chg">http://www.w3.org/TR/2011/WD-WebIDL-20110927/
</ins>
</a>
</dd>
</dl>
</div>
<div id="informative-references" class="section">
<h3>
<span class="secno">
<del class="diff-old">A.2
</del>
<ins class="diff-chg">C.2
</ins>
</span>
Informative
references
</h3>
<dl class="bibliography">
<dt id="bib-ECMA-262">
[ECMA-262]
</dt>
<dd>
<a href="http://www.ecma-international.org/publications/standards/Ecma-262.htm">
<cite>
ECMAScript
Language
<del class="diff-old">Specification,
Third
Edition.
</del>
<ins class="diff-chg">Specification.
</ins>
</cite>
</a>
December
1999.
URL:
<a href="http://www.ecma-international.org/publications/standards/Ecma-262.htm">
http://www.ecma-international.org/publications/standards/Ecma-262.htm
</a>
</dd>
<dt id="bib-MICRODATA">
[MICRODATA]
</dt>
<dd>
Ian
Hickson;
et
al.
<a href="http://www.w3.org/TR/microdata/">
<cite>
Microdata
</cite>
</a>
04
March
2010.
W3C
Working
Draft.
URL:
<a href="http://www.w3.org/TR/microdata/">
http://www.w3.org/TR/microdata/
</a>
</dd>
<dt id="bib-MICROFORMATS">
[MICROFORMATS]
</dt>
<dd>
<a href="http://microformats.org">
<cite>
Microformats
</cite>
</a>.
URL:
<a href="http://microformats.org">
http://microformats.org
</a>
</dd>
<dt id="bib-RDFA-CORE">
[RDFA-CORE]
</dt>
<dd>
Shane
McCarron;
et
al.
<a href="http://www.w3.org/TR/2011/WD-rdfa-core-20111215">
<cite>
RDFa
Core
1.1:
Syntax
and
processing
rules
for
embedding
RDF
through
attributes.
</cite>
</a>
<del class="diff-old">31
March
</del>
<ins class="diff-chg">15
December
</ins>
2011.
W3C
Working
Draft.
URL:
<del class="diff-old">http://www.w3.org/TR/2011/WD-rdfa-core-20110331
</del>
<a href="http://www.w3.org/TR/2011/WD-rdfa-core-20111215">
<ins class="diff-chg">http://www.w3.org/TR/2011/WD-rdfa-core-20111215
</ins></a></dd><dt id="bib-XML-NAMES"><ins class="diff-chg">
[XML-NAMES]
</ins></dt><dd><ins class="diff-chg">
Richard
Tobin;
et
al.
</ins><a href="http://www.w3.org/TR/2009/REC-xml-names-20091208/"><cite><ins class="diff-chg">
Namespaces
in
XML
1.0
(Third
Edition).
</ins></cite></a><ins class="diff-chg">
8
December
2009.
W3C
Recommendation.
URL:
</ins><a href="http://www.w3.org/TR/2009/REC-xml-names-20091208/"><ins class="diff-chg">
http://www.w3.org/TR/2009/REC-xml-names-20091208/
</ins>
</a>
</dd>
</dl>
</div>
</div>
</body>
</html>